# Hvordan konvertere et int til en streng i Java

Hvis du vil konvertere en Java int til en streng, er det fem alternativer. Vi viser deg de forskjellige måtene.

## Hva er int til strengkonvertering i Java?

Hvis du jobber med programmeringsspråket Java, vil du støte på ulike [Java-datatyper](https://www.ionos.com/nb-no/digitalguide/nettsteder/webutvikling/java-datatyper/) og på et tidspunkt måtte konvertere et int til en streng. Heltall (int) er en av de [primitive Java-datatypene](https://www.ionos.com/nb-no/digitalguide/nettsteder/webutvikling/java-primitiver/). Heltallvariabler kan bare inneholde hele tall mellom -2147483648 og 2147483647. [Java-strenger](https://www.ionos.com/nb-no/digitalguide/nettsteder/webutvikling/java-strenger/) er derimot en kompleks datatype som kan inneholde bokstaver, tall og spesialtegn. Hvis du vil konvertere et int til en streng, har du fem alternativer. Vi presenterer hvert av dem nedenfor. Alternativene er:

- Metoden `Integer(int).toString` fra heltallsklassen
- Metoden `valueOf()` fra strengklassen
- Metoden `String.format()` fra strengklassen
- Legge til int en tom streng
- Klassen DecimalFormat

Hvis du vil vite hvordan du gjør det motsatte og [konverterer en streng til et heltall](https://www.ionos.com/nb-no/digitalguide/nettsteder/webutvikling/java-streng-til-int/), kan du lese artikkelen i vår digitale guide.

## Hvordan bruke Integer.toString()

En av de enkleste og mest praktiske metodene for å konvertere en Java int til en streng er metode `Integer(int).toString`. Den grunnleggende syntaksen for denne metoden ser slik ut:

```Java
Integer.toString(Integer);
```

Med denne metoden konverteres heltallet og returneres som en strenginstans. I eksemplet nedenfor oppretter vi et heltall med navnet «amount» og tildeler det verdien 5. Deretter legger vi det inn som en parameter i metoden `Integer.toString()`. Vi tildeler denne nye strengverdien til strengvariabelen VEHICLES. Deretter kombinerer vi denne strengen med andre strenger og bruker Java-kommandoen `System.out.println` for utdata. Koden for alt dette ser slik ut:

```java
public class Main {
	public static void main(String[] args) {
	int amount = 5;
	String VEHICLES = Integer.toString(amount);
	System.out.println("There are " + VEHICLES + " cars in the car park");
	}
}
```

Resultatet vil se slik ut:

```java
There are 5 cars in the car park
```

## Hvordan bruke String.valueOf()

Metoden `String.valueOf()` fungerer på samme måte og gjør det mulig å raskt konvertere et int til en streng i Java. For å bruke den, oppretter vi først et heltall med navnet «amount» og legger det inn som parameter i `String.valueOf()`. Den grunnleggende syntaksen ser slik ut:

```java
String.valueOf(Integer);
```

Eksemplet ovenfor vil se slik ut:

```java
public class Main {
	public static void main(String[] args) {
	int amount = 5;
	String VEHICLES = String.valueOf(amount);
	System.out.println("There are " + VEHICLES + " cars in the car park");
	}
}
```

Resultatet ser slik ut:

```java
There are 5 cars in the car park
```

## Hvordan bruke String.format()

Den neste metoden er litt mindre direkte, men fungerer også godt. Den har to parametere, en variabel som i eksemplene ovenfor og plassholderen «%d». Plassholderen brukes til å formatere strengene og erstatter et helt tall. Vi vil igjen kalle variabelen «amount» og konvertere den til strengen «VEHICLES». Den grunnleggende syntaksen for `String.format()` ser slik ut:

```java
String.format(placeholder, integer);
```

Koden vil da se slik ut:

```java
public class Main {
	public static void main(String[] args) {
	int amount = 5;
	String VEHICLE = String.format("%d", amount);
	System.out.println("There are " + VEHICLES + " cars in the car park");
	}
}
```

Og vi får igjen utdataene:

```java
There are 5 cars in the car park
```

## Hvordan koble et heltall til en tom streng

Hvis du vil konvertere et heltall til en streng i Java med en tom streng, trenger du operatoren `+`. Du kan bruke `+` til å legge heltallet til en tom streng og angi resultatet som en streng. La oss se på et eksempel:

```java
public class Main {
	public static void main(String[] args) {
	int amount = 5;
	String VEHICLES = "" + amount;
	System.out.println("There are " + VEHICLES + " cars in the car park");
	}
}
```

Utdataene ser igjen ut som følger:

```java
There are 5 cars in the car park
```

## Hvordan bruke DecimalFormat

Vår siste mulighet for å konvertere en Java int til en streng bruker klassen DecimalFormat og krever noen ekstra trinn. Først må klassen importeres. Deretter kan vi opprette int-variabelen «amount». Deretter trenger vi et nytt objekt for klassen DecimalFormat, som vi kaller «NewFormat». Til slutt bruker vi metoden `format()` for å konvertere `amount` til en streng. Koden ser slik ut:

```java
import java.text.DecimalFormat;
public class Main {
	public static void main(String[] args) {
	int amount = 5;
	DecimalFormat NewFormat = new DecimalFormat("#");
	String VEHICLE = NewFormat.format(amount);
	System.out.println("There are " + VEHICLES + " cars in the car park");
	}
}
```

Utdataene ser ut som ovenfor:

```java
There are 5 cars in the car park
```


This is a markdown version of: [https://www.ionos.com/nb-no/digitalguide/nettsteder/webutvikling/java-int-til-string/](https://www.ionos.com/nb-no/digitalguide/nettsteder/webutvikling/java-int-til-string/) for AI/LLM consumption.