# Sådan bruges Java-strenge

Java-strenge er en af de komplekse [datatyper i Java](https://www.ionos.com/da-dk/digitalguide/websteder/webudvikling/java-datatyper/). De bruges til at repræsentere og ændre en sekvens af tegn eller cifre. Der findes en række metoder, der kan hjælpe dig med at ændre strenge. I denne vejledning giver vi en introduktion til, hvad du behøver at vide om strenge i Java.

## Hvad er Java-strenge, og hvad bruges de til?

Programmeringssproget Java har mange forskellige datatyper. De vigtigste er [Java-primitiver](https://www.ionos.com/da-dk/digitalguide/websteder/webudvikling/java-primitiver/) som integer og char samt komplekse datatyper som strings. En string er en **sekvens af tegn eller cifre**, der findes som et objekt i java.lang-klassen. Strings oprettes med String-klassen og kan derefter ikke længere ændres. På trods af dette bruges Java-strings stadig oftere end [StringBuilder](https://www.ionos.com/da-dk/digitalguide/websteder/webudvikling/java-stringbuilder/), som giver dig mulighed for at ændre strings, efter at de er oprettet. Nedenfor forklarer vi, hvordan du opretter en streng, og hvilke metoder du har til rådighed.

## Hvad er syntaksen for Java-strenge?

Hvis du vil oprette en ny streng i Java, kan du bruge denne enkle syntaks:

```java
String name = "string";
```

Du signalerer til systemet, at du vil oprette en Java-streng, giver strengen et navn og indtaster derefter tegnene i strengen **mellem anførselstegnene**. Hvis du senere vil henvise til den streng, skal du bruge det navn, du har givet den. Sådan ser koden til oprettelse af en streng ud:

```java
public class Main {
	public static void main(String[] args) {
	String example = "Here’s your first Java string.";
	System.out.println(example);
 }
}
```

Resultatet ser således ud:

```java
Here’s your first Java string.
```

## Hvilke metoder bruges med Java-strenge?

Da Java-strenge er objekter, er der en række metoder, du kan bruge med dem. Nedenfor introducerer vi de vigtigste.

### `length()`

Metoden `length()` bruges til **at udskrive det samlede antal tegnværdier i en streng**. Du får længden af din streng som output. Her er syntaksen:

```java
stringName.length()
```

Det er også meget nemt at anvende. Koden ser således ud:

```java
public class Main {
	public static void main(String[] args) {
	String example = "Here’s your first Java string.";
	int length = example.length();
	System.out.println("The string is " + length + " characters long.");
 }
}
```

Og du får følgende output:

```java
The string is 30 characters long.
```

### `indexOf()`

Du kan bruge `indexOf()` til **at finde en eller flere delstrenge i din større streng**. Her er syntaksen for det:

```java
stringName.indexOf()
```

For at bruge metoden skal du blot indtaste den del af strengen, du vil finde.

```java
public class Main {
	public static void main(String[] args) {
	String example = "Here’s your first Java string.";
	System.out.println(example.indexOf("your"));
 }
}
```

Som output får du den position, hvor teksten først vises:

```java
7
```

### `concat()`

Med `concat()` kan du **forbinde to separate strenge** for at danne en ny streng. Her er dens syntaks:

```java
stringName.concat(string1)
```

Sådan fungerer metoden i praksis:

```java
public class Main {
	public static void main(String[] args) {
	String example = "word";
	String newString = example.concat("smith");
	System.out.println(newString);
 }
}
```

Her er resultatet:

```java
wordsmith
```

### `equals()`

`equals()` er en af mange metoder, du kan bruge til at sammenligne Java-strenge med hinanden. Metoden returnerer en **boolsk værdi (sand eller falsk)**. Her er dens syntaks:

```java
string1.equals(string2)
```

I vores eksempel opretter vi tre strenge og sammenligner derefter den første med de to andre:

```java
public class Main {
	public static void main(String[] args) {
	String string1 = "ABC";
	String string2 = "ABC";
	String string3 = "DEF";
	System.out.println(string1.equals(string2));
	System.out.println(string1.equals(string3));
 }
}
```

Da den første og anden streng er identiske, og den tredje ikke er det, får du følgende output:

```java
true
false
```

### `toUpperCase()` og `toLowerCase()`

De to metoder `toUpperCase()` og `toLowerCase()` bruges til at konvertere tegnværdierne i en streng til **store eller små bogstaver**. Her er syntaksen for hver af dem:

```java
stringName.toUpperCase()
stringName.toLowerCase()
```

Sådan fungerer de:

```java
public class Main {
	public static void main(String[] args) {
	String example = "Here’s your first Java string.";
	System.out.println(example.toUpperCase());
	System.out.println(example.toLowerCase());
 }
}
```

Her er resultatet:

```java
HERE’S YOUR FIRST JAVA STRING.
here's your first java string.
```

### `split()`

Med [Java](https://www.ionos.com/da-dk/digitalguide/websteder/webudvikling/strengopdeling-i-java/) -metoden [split()](https://www.ionos.com/da-dk/digitalguide/websteder/webudvikling/strengopdeling-i-java/) kan du **opdele en Java-streng i mindre delstrenge**. Her er dens syntaks:

```java
String[] split(String regex)
```

Sådan ser det ud i praksis:

```java
public class Main {
	public static void main(String[] args) {
		String x = "Here’s your first Java string";
		String[] output = x.split(" ");
		for (String y : output) {
			System.out.println(y);
		}
	}
}
```

Resultatet ser således ud:

```java
Here’s
your
first
Java
string.
```


This is a markdown version of: [https://www.ionos.com/da-dk/digitalguide/websteder/webudvikling/java-strenge/](https://www.ionos.com/da-dk/digitalguide/websteder/webudvikling/java-strenge/) for AI/LLM consumption.