Meny

8 metoder för att konvertera ett heltal till sträng i Java

  • Huvud
  • Övrig
  • 8 metoder för att konvertera ett heltal till sträng i Java

8 methods convert an integer string java

Prova Vårt Instrument För Att Eliminera Problem

I denna handledning kommer vi att undersöka de olika metoderna för att konvertera heltal till sträng i Java tillsammans med intressanta programmeringsexempel:

Vi kommer att täcka användningen av följande metoder som tillhandahålls av de olika Java-klasserna för att konvertera Int till String i Java:

  • Strängsammankoppling
  • String.valueOf ()
  • String.format ()
  • Integer.toString ()
  • Integer.String (int)
  • StringBuilder append ()
  • StringBuffer append ()
  • DecimalFormat-format ()

Vi kommer att ta en titt på dessa metoder i detalj en efter en.

=> Besök här för att lära dig Java från grunden

Java-metod för att konvertera int till String

Vad du kommer att lära dig:

Dold heltal till sträng i Java

I olika scenarier är det nödvändigt att skriva ett Java-program för att konvertera ett heltal till String medan du utvecklar alla applikationer eller webbplatser.

Låt oss överväga ett scenario i vårt Java-program, där efter att ha utfört vissa aritmetiska operationer på int-variabler är det mottagna resultatvärdet ett heltal. Detta värde måste emellertid skickas till något textfält eller textområdesfält på webbsidan. I sådana fall krävs det att först konvertera detta int-värde till String.

# 1) Använda strängkompatering

Vi har använt Java plus ‘+’ operatör flera gånger. Detta används ofta när man skriver ut alla utdata på konsolen med metoden System.out.println ().

package com.softwaretestinghelp; /** * This class demonstrates sample code to convert int to String Java program * using String concatenation * * @author * */ public class IntStringDemo1 { public static void main(String() args) { // Assign int 25 to int variable length int length = 25; // Assign int 10 to int variable width int width = 10; // Multiply variable value length and width and assign to calculatedArea int calculatedArea = length * width; // concatenate calculatedArea to String 'Variable calculatedArea Value --->' using plus ‘+’ // operator // print variable int type calculatedArea System.out.println('Variable calculatedArea Value --->' + calculatedArea); } }

Här är programmet Output:
Variabel beräknad Arealvärde -> 250

I ovanstående program sammanfogar vi int beräknat område med strängen 'Variabel beräknad area Värde ->' enligt följande:

“Variabel beräknat områdevärde ->” + beräknat område

Detta omvandlar int beräknat område till String. Sedan skickas denna sträng som ett argument till System. ut .println () metod för att skriva ut på konsolen enligt följande:

Systemet. ut .println ('Variabel beräknat områdevärde ->' + beräknat område);

Detta skriver strängen på konsolen:

Variabel beräknad Arealvärde -> 250

Konvertera med hjälp av String concatenation

# 2) Använda String.ValueOf () -metoden

Strängklassen har statiska överbelastningsmetoder för valueOf (). Syftet med dessa överbelastningsmetoder är att konvertera argument för primitiva datatyper som int, long, float till String-datatyp.

Låt oss titta på metodesignaturen för int-datatypen nedan:

public static String valueOf (int i)
Den här statiska metoden tar emot ett argument av datatyp int och returnerar strängrepresentationen för int-argumentet.
Parametrar:
i: Detta är ett heltal.
Returer:
Strängrepresentationen för int-argumentet.

Låt oss förstå hur vi använder denna String.valueOf () -metod med följande exempelprogram. I det här programmet lägger vi till två nummer och använder metoden String.valueOf () för att konvertera heltalet sumValue till String.

Nedan följer ett exempelprogram för din referens:

package com.softwaretestinghelp; /** * This class demonstrates sample code to convert int to String Java program * using String.valueOf() method * * @author * */ public class IntStringDemo2 { public static void main(String() args) { // Assign int 300 to int variable x int x = 300; // Assign int 200 to int variable y int y = 200; // Add variable value x and y and assign to sumValue int sumValue = x + y; // Pass sumValue as an argument to String.valueOf() to convert // sumValue to String String sum = String.valueOf(sumValue); // print variable String sum System.out.println('Variable sum Value --->' +sum); } }

Här är programmet Output:
Variabel summa Värde -> 500

# 3) Använda String.format () -metoden

Strängklassen har en statisk metod för att konvertera argument till det angivna formatet.

Låt oss titta på metodesignaturen nedan:

offentligt statiskt strängformat (strängformat, objekt ... args)
Detta är en statisk metod för strängklass som använder angivet strängformat och argument för argument argumenterar och returnerar formaterad sträng. Vid fler argument än formatspecifikationer ignoreras argument som är extra. Antalet argument är varierande, kanske noll.

Parametrar:
format: formatsträng
args: argument som måste formateras enligt formatsträngen

Returer:
En sträng formaterad enligt den angivna formatsträngen

Kastar:
Den här metoden kastar IllegalFormatException, NullPointerException.

Låt oss förstå användningen av den här metoden String.format ().

Låt oss se samma programkod för att jämföra två heltal. Programmet skriver ut ett större antal bland två nummer. Detta program använder metoden String.format () för att konvertera heltalet stort antal att stränga.

Ett exempelprogram ges nedan:

package com.softwaretestinghelp; /** * This class demonstrates sample code to convert int to String Java program * using String.format() method * * @author * */ public class IntStringDemo3 { public static void main(String() args) { // Assign int 25 to int variable a int a = 25; // Assign int -50 to int variable b int b = -50; // Compare two numbers a and b int largeNumber = 0; if(a>b) { //if a is greater than b assign it to largeNumber variable largeNumber = a; }else { //if a is less than b then assign b to largeNumber variable largeNumber = b; } // Pass largeNumber as an argument to String.format() to convert // largeNumber to String String largeNumberString = String.format('|%5d|',largeNumber); // print variable String largeNumberString System.out.println('Variable largeNumber Value --->' + largeNumberString); } }

Här är programmet Output:
Variabelt stortNummervärde -> | 25 |

I ovanstående exempelkod har vi använt metoden String.format (). Vi använder “|% 5d |” som ett format och passerar int-värde largeNumber enligt nedan:

String largeNumberString = Sträng. formatera (“|% 5d |”, largeNumber);

String.format () returnerar formaterad String enligt det angivna formatet '|% 5d |' dvs. antal som anges i '||' med bredd 5 och högerjusterat d.v.s. | 25 | och skriver ut detsamma på konsolen.

Systemet. ut .println (“Variable largeNumber Value ->” + largeNumberString);

Så, utgången på konsolen är Variabelt stortNummervärde -> | 25 |

Låt oss nu se heltalet till String Java-konverteringsmetoder som tillhandahålls av klassen Integer.

öppna en dat-fil på mac

Vi kommer att se följande metoder för heltalsklasser:

      • Heltal (int) .toString ().
      • Integer.toString (int)

# 4) Använda Integer (int) .toString () -metoden

Heltal klass ger en metod att stränga () för att konvertera int till String.

Låt oss titta på metodesignaturen nedan:

offentlig sträng till sträng ()
Den här metoden konverterar värdet till den signerade decimalrepresentationen och returnerar ett strängobjekt.

Låt oss förstå användningen av detta Heltal (int) .toString () metod.

Låt oss se exempelkoden för att beräkna resten av två siffror och skriva ut på konsolen med metoden Integer (int) .toString () för att konvertera heltalet restValue till dess strängrepresentation.

Här är exempelprogrammet nedan:

package com.softwaretestinghelp; /** * This class demonstrates sample code to convert int to String Java program * using Integer.toString() method * * @author * */ public class IntStringDemo4 { public static void main(String() args) { // Assign int 33 to int variable dividentValue int dividentValue = 33; // Assign int 5 to int variable dividerValue int dividerValue = 5; // Calculate remainder of dividentValue and dividerValue using modulus int remainderValue = dividentValue % dividerValue; // Pass remainderValue as an argument to new Integer() to convert it to Integer object Integer remainderIntValue = new Integer(remainderValue); // Invoke toString() method on Integer object remainderIntValue convert it to String String remainder = remainderIntValue.toString(); // print variable String remainder System.out.println('Variable remainder Value --->' + remainder); } } }

Här är programmet Output:
Variabel restvärde -> 3

I ovanstående program har vi skapat instans av Integer-klassen

ny Heltal (restvärde);

och åberopade toString () -metoden på den enligt nedan:

Strängrester = remainderIntValue.toString ();

Detta uttalande returnerar strängrepresentationen för Integer-klassobjektet remainderIntValue.

# 5) Använda Integer.toString (int) -metoden

Heltal ger också en statisk metod att stränga () för att konvertera int till String.

Låt oss titta på metodesignaturen nedan:

offentlig statisk String toString (int i)
Den här statiska metoden returnerar String-objektrepresentationen för det angivna heltalet. Här konverteras ett argument till signerad decimalrepresentation och returneras som en sträng. Detta är exakt samma som den överbelastade metoden toString (int i, int radix) där radixvärdet är 10.
Parametrar:
i: Detta är ett heltal som måste konverteras
Returer:
En strängrepresentation av argumentet jag har radix 10.

Låt oss förstå användningen av detta Heltal . toString (int i) metod.

Låt oss skriva exempelprogrammskoden som uppmanar användaren att ange numret, beräkna kvadraten på numret och skriva ut kvadrat på konsolen med metoden Integer.toString (int i) för att konvertera heltalet kvadratvärde till String.

Här är exempelprogrammet nedan:

package com.softwaretestinghelp; import java.util.Scanner; /** * This class demonstrates sample code to convert int to String Java program * using Integer.toString(int i ) method * * @author * */ public class IntStringDemo5 { private static Scanner scanner; public static void main(String() args) { //Prompt user to enter input using Scanner and here System.in is a standard input stream scanner = new Scanner(System.in); System.out.print('Please Enter the number'); //Scan the next token of the user input as an int and assign it to variable x int x= scanner.nextInt(); //Calculate square of the number assigned to x int squareValue = x*x; // Pass squareValue as an argument to Integer.toString() to convert // squareValue to String String square = Integer.toString(squareValue); // print variable String square System.out.println('Variable square Value --->' + square); } }

Här är programmet Output:
Ange nummer 5
Variabelt kvadratvärde -> 25

I ovanstående program åberopade vi den statiska metoden toString on Integer class genom att skicka squareValue som ett argument

Sträng kvadrat = heltal. att stränga (squareValue);

Detta returnerar en strängrepresentation av int-värdet squareValue

Låt oss se några fler sätt, dvs. använda klassmetoder StringBuffer, StringBuilder.

StringBuffer-klassen används för att lägga till flera värden till String. StringBuilder gör den exakta uppgiften, den enda skillnaden är att StringBuffer är trådsäker, men StringBuilder inte.

Rekommenderad läsning => Java String Tutorial

# 6) Använda StringBuilder klassmetoder

Låt oss se hur man använder StringBuilder-metoder för att konvertera int till String i Java.

Här är metodens signaturer:

public StringBuilder append (int i)
Denna metod lägger till strängrepresentationen för int-argumentet i sekvensen.
Parametrar:
i: Detta är ett heltal.
Returer:
Detta är en hänvisning till objektet.

offentlig sträng till sträng ()
Denna metod returnerar en sträng som representerar data i denna sekvens.

Nedan följer ett exempelprogram som beräknar genomsnittet av heltalsvärden och illustrerar användningen av StringBuilder för att konvertera heltalet avgNumber till String.

package com.softwaretestinghelp; /** * This class demonstrates sample code to convert int to String Java program * using StringBuilder append() toString() method * * @author * */ public class IntStringDemo6 { public static void main(String() args) { // Assign values to array of type int int() numArray = {15,25,60,55}; //Find the array size int arrLength = numArray.length; int arrSum = 0; //Calculate addition of all numbers for(int i=0;i' + average); } }

Här är programmet Output:
Variabelt medelvärde -> 38

I programmet ovan använde vi StringBuilder append () -metoden och konverterade StringBuilder-objekt till String med metoden toString ()

strbAvg.append (avgNumber);
Stränggenomsnitt = strbAvg.toString ();

# 7) Använda StringBuffer klassmetoder

Låt oss se Java konvertera int till String sätt med StringBuffer metoder.

Här är metodens signaturer:

public StringBuffer append (int i)
Denna metod lägger till strängrepresentationen för int-argumentet i sekvensen.

Parametrar:
i: Detta är ett heltal.

Returer:
Detta är en hänvisning till objektet.

offentlig sträng till sträng ()
Denna metod returnerar en sträng som representerar data i denna sekvens.

Låt oss ta en titt på exempelprogrammet nedan. Vi använder den lägre Math.min () -metoden för att hitta det lägre värdet bland 2 int-värden och StringBuffer-metoder för att konvertera helvärdet minValue till String.

package com.softwaretestinghelp; /** * This class demonstrates sample code to convert int to String Java program * using StringBuffer append() toString() method * * @author * */ public class IntStringDemo7 { public static void main(String() args) { // Assign int 60 to int variable a int a = 60; // Assign int -90000 to int variable b int b = -90000; // Get lower value between int a and b using Math class method min() int minValue = Math.min(a, b); // Pass minValue as an argument to StringBuffer.append() method StringBuffer strbMinValue = new StringBuffer(); strbMinValue.append(minValue); //Convert strbMinValue to String using toString() method String minimumValue = strbMinValue.toString(); // print variable String miniumValue System.out.println('Variable miniumValue Value --->' + minimumValue); } }

Här är programmet Output:
Variabelt miniumValue-värde -> - 90000

I ovanstående program använde vi StringBuffer append () -metoden och konverterade StringBuffer-objekt till String med metoden toString ()

strbMinValue.append (minValue);
Sträng minimumValue = strbMinValue.toString ();

# 8) Använda DecimalFormat-klassmetoder

Java int kan också konverteras till sträng med java.text.DecimalFormat klassmetoden.

Här är metodens signatur för formatet () -metoden för klassen.

NumberFormat. DecimalFormat utökar NumberFormat-klassen.
offentlig final Strängformat (långt antal)
Den här metoden returnerar den formaterade strängen för argumentet för datatyp long
Parametrar:
nummer: Detta är värdet på datatypen lång
Returer:
den formaterade strängen

Nedan följer ett exempelprogram som illustrerar användningen av klassmetoden DecimalFormat för att konvertera heltal elementValue till String.

package com.softwaretestinghelp; import java.text.DecimalFormat; import java.util.Scanner; /** * This class demonstrates sample code to convert int to String Java program * using DecimalFormat format() method * * @author * */ public class IntStringDemo8 { private static Scanner scanner; public static void main(String() args) { // Assign values to array of arrays of type int int()() numArray = { {15,20,30,60}, {300,600,900} }; //Prompt user to enter input using Scanner and here System.in is a standard input stream scanner = new Scanner(System.in); System.out.println('Please Enter the array number'); //Scan the next token of the user input as an int and assign it to variable x int x= scanner.nextInt(); System.out.println('Please Enter the element number'); //Scan the next token of the user input as an int and assign it to variable y int y= scanner.nextInt(); int elementValue = numArray(x)(y); System.out.println(elementValue); // Pass '#' as format for DecimalFormat DecimalFormat formatElement = new DecimalFormat('#'); //Pass elementValue as an argument to format() method to convert it to String String element = formatElement.format(elementValue); // print variable String element System.out.println('Variable element Value --->' + element); } }

Här är programmet Output:
Ange arraynumret
1
Vänligen ange elementnumret
1
600
Variabelt element Värde -> 600

I ovanstående program använde vi metoden DecimalFormat class format () och konverterade int elementValue till String enligt nedan:

Strängelement = formatElement.format (elementValue);

Således har vi täckt flera metoder för att konvertera Java-heltal till ett strängvärde. I alla exempelprogram har vi sett olika scenarier där det krävs att konvertera helvärden till strängvärden och konsolutgången visas.

Så för att konvertera ett heltal till String i Java kan någon av metoderna som visas i ovanstående exempelkoder användas i ditt Java-program.

Nedan följer några av de vanliga frågorna om konvertering int till sträng.

Vanliga frågor om konvertering till sträng i Java

F # 1) Kan vi konvertera int till String i Java?

Svar: Ja , i Java kan vi konvertera int till String.

Vi kan konvertera int till String med följande metoder:

  • Strängsammankoppling
  • String.valueOf ()
  • String.format ()
  • Integer.toString ()
  • Integer.String (int)
  • StringBuilder append ()
  • StringBuffer append ()
  • DecimalFormat-format ()

F # 2) Kan vi skriva cast int to string?

gratis youtube till mp4-omvandlare för mac

Svar: Ja, vi kan konvertera int till String med klassmetoderna String och Integer som String.valueOf (), Integer.toString () etc.

F # 3) Hur konverterar vi en sträng till ett tal?

Svar: Sträng kan konverteras till ett antal typer int med metoderna för Integer-klass som Integer.valueOf () och Integer.parseInt ()

Slutsats

I denna handledning undersökte vi hur man konverterar ett heltal till String i Java med hjälp av följande metoder:

  • Strängsammankoppling
  • String.valueOf ()
  • String.format ()
  • Integer.toString ()
  • Integer.String (int)
  • StringBuilder append ()
  • StringBuffer append ()
  • DecimalFormat-format ()

Vi täckte varje metod i detalj och illustrerade användningen av varje metod med hjälp av ett exempel.

=> Utforska The Simple Java Training Series här

Rekommenderad läsning

^