# Sådan bruges Java-metoden substring

Javas substring-metode bruges til at udtrække en substring fra en større streng. Der er to forskellige måder at bruge den på: enten ved at adskille strengen fra et indeks til slutningen eller med et foruddefineret start- og slutindeks for substringen.

## Hvad er Java-substring-metoden, og hvordan bruges den?

I Java kan tegn, cifre og specialtegn kombineres i en [Java-streng](https://www.ionos.com/da-dk/digitalguide/websteder/webudvikling/java-strenge/). Hvis du vil udtrække en bestemt delmængde fra den større streng, har du flere muligheder. Metoden [Java String.split()](https://www.ionos.com/da-dk/digitalguide/websteder/webudvikling/strengopdeling-i-java/) opdeler en hel streng i dens enkelte dele for eksempelvis at give dig et klarere overblik over strengen. Metoden `substring()` går et skridt videre og returnerer kun den del af strengen, som du definerer. Du kan definere, hvilken del af strengen du vil udtrække, **ved udelukkende at** bruge **et startindeks eller både et start- og slutindeks**. I denne tutorial introducerer vi Java’s `substring()` metode i dens forskellige former.

## Sådan bruges Java `substring()` med `beginIndex`

Som nævnt ovenfor er der to måder at bruge Java’s `substring()` på. Den første **definerer kun startpunktet** for den delstreng, du vil udtrække. Den opdeler strengen fra det indeks til det sidste tegn i strengen. Dens syntaks ser således ud:

```java
String substring(int beginIndex)
```

For at bruge `substring()` skal du først indtaste den streng, som du vil udtrække delstrengen fra. Derefter bruger du et heltal til at definere, hvor delstrengen skal begynde. Du kan se resultatet med Java-kommandoen `System.out.println`. Metoden fungerer **inklusivt**, hvilket betyder, at det tegn, der befinder sig i den position, du indtaster, også vil blive adskilt. Hvis værdien af `beginIndex` er mindre end 0 eller større end den faktiske længde af strengen, får du en fejlmeddelelse.

Lad os se på et simpelt eksempel for at se, hvordan `substring()` fungerer i Java. Vi opretter en streng og udtrækker derefter en delstreng.

```java
public class Main {
	public static void main(String args[]) {
	String Str = new String("This is an example. This is another sentence.");
	System.out.print("The substring is: ");
	System.out.println(Str.substring(20));
	}
}
```

Når du kører koden, får du følgende output:

```java
The substring is: This is another sentence.
```

Det fungerer selvfølgelig lige så godt med tal:

```java
public class Main {
	public static void main(String args[]) {
	String Str = new String("192.448.782.1142");
	System.out.print("The last four digits are: ");
	System.out.println(Str.substring(12));
	}
}
```

Her er resultatet:

```java
The last four digits are: 1142
```

## Sådan bruges `substring()` sammen med `beginIndex` og `endIndex`

Den anden måde at bruge Java’s `substring()` på giver større kontrol over den resulterende delstreng. Du angiver ikke kun startpunktet for delstrengen, men også **et slutpunkt**. Syntaksen ser således ud:

```java
String substring(int beginIndex, int endIndex)
```

`beginIndex` er inklusivt, og `endIndex` er eksklusivt. Lad os endnu en gang se på et simpelt eksempel:

```java
public class Main {
	public static void main(String args[]) {
	String Str = new String("This is an example. This is another sentence.");
	System.out.print("The substring is: ");
	System.out.println(Str.substring(8, 18));
	}
}
```

Outputtet er:

```java
The substring is: an example
```

Du kan også nemt udtrække en delstreng fra et enkelt ord. I det næste eksempel opretter vi en indkøbsliste:

```java
public class Main {
	public static void main(String args[]) {
	String Str = new String("Eggs, Honey, Milk, Bread");
	System.out.print("The substring is: ");
	System.out.println(Str.substring(7, 10));
	}
}
```

Den nye output vil se således ud:

```java
The substring is: one
```

I vores sidste eksempel viser vi en praktisk anvendelse af Java’s `substring()`. Forestil dig, at du har modtaget kundedata i et bestemt format. Hvis du kun vil isolere en del af disse oplysninger, er `substring()` perfekt. Lad os se på koden:

```java
public class Main {
	public static void main(String args[]) {
	String Str = new String("247: Taylor, Javal|taylorj@example.com|London|12.04.1972");
	System.out.print("Here is the customer’s email address: ");
	System.out.println(Str.substring(19, 38));
	}
}
```

Her er resultatet:

```java
Here is the customer’s email address: taylorj@example.com
```


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