# Hvordan bruke Java-strenger

Java-strenger er en av de komplekse [datatypene i Java](https://www.ionos.com/nb-no/digitalguide/nettsteder/webutvikling/java-datatyper/). De brukes til å representere og endre en sekvens av tegn eller siffer. Det finnes en rekke metoder som kan hjelpe deg med å endre strenger. I denne veiledningen gir vi en introduksjon til det du trenger å vite om strenger i Java.

## Hva er Java-strenger, og hva brukes de til?

Programmeringsspråket Java har mange forskjellige datatyper. De viktigste inkluderer [Java-primitiver](https://www.ionos.com/nb-no/digitalguide/nettsteder/webutvikling/java-primitiver/) som heltall og tegn, og komplekse datatyper som strenger. En streng er en **sekvens av tegn eller siffer** som eksisterer som et objekt i java.lang-klassen. Strenger opprettes med String-klassen og kan deretter ikke endres. Til tross for dette brukes Java-strenger fortsatt oftere enn [StringBuilder](https://www.ionos.com/nb-no/digitalguide/nettsteder/webutvikling/java-stringbuilder/), som lar deg endre strenger etter at de er opprettet. Nedenfor forklarer vi hvordan du oppretter en streng og hvilke metoder du har til rådighet.

## Hva er syntaksen for Java-strenger?

Hvis du vil opprette en ny streng i Java, kan du bruke denne enkle syntaksen:

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

Du signaliserer til systemet at du vil opprette en Java-streng, gir strengen et navn og skriver deretter inn tegnene i strengen **mellom anførselstegnene**. Hvis du vil referere til den strengen senere, bruker du navnet du ga den. Slik ser koden for å opprette en streng ut:

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

Resultatet ser slik ut:

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

## Hvilke metoder brukes med Java-strenger?

Siden Java-strenger er objekter, finnes det en rekke metoder du kan bruke med dem. Nedenfor presenterer vi de viktigste.

### `length()`

Metoden `length()` brukes til **å gi ut det totale antallet tegnverdier i en streng**. Du får lengden på strengen som utdata. Her er syntaksen:

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

Det er også veldig enkelt å bruke. Koden ser slik ut:

```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 utdata:

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

### `indexOf()`

Du kan bruke `indexOf()` til **å finne en eller flere delstrenger i en større streng**. Her er syntaksen for dette:

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

For å bruke metoden, skriv inn den delen av strengen du ønsker å finne.

```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 utdata får du posisjonen der teksten først vises:

```java
7
```

### `concat()`

Med `concat()` kan du **koble sammen to separate strenger** for å danne en ny streng. Her er syntaksen:

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

Slik 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 av mange metoder du kan bruke til å sammenligne Java-strenger med hverandre. Metoden returnerer en **boolsk verdi (sann eller falsk)**. Her er syntaksen:

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

I vårt eksempel skal vi opprette tre strenger og deretter sammenligne 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));
 }
}
```

Siden den første og andre strengen er identiske, mens den tredje ikke er det, får du følgende utdata:

```java
true
false
```

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

De to metodene `toUpperCase()` og `toLowerCase()` brukes til å konvertere tegnverdiene i en streng til **store eller små bokstaver**. Her er syntaksen for hver av dem:

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

Slik 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/nb-no/digitalguide/nettsteder/webutvikling/strengdeling-i-java/) -metoden [split()](https://www.ionos.com/nb-no/digitalguide/nettsteder/webutvikling/strengdeling-i-java/) kan du **dele en Java-streng i mindre delstrenger**. Her er syntaksen:

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

Slik ser det ut 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 slik ut:

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


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