# Hoe Java-strings te gebruiken

Java-strings zijn een van de complexe [gegevenstypen in Java](https://www.ionos.com/nl-be/digitalguide/websites/webontwikkeling/java-gegevenstypen/). Ze worden gebruikt om een reeks tekens of cijfers weer te geven en te wijzigen. Er zijn verschillende methoden beschikbaar om strings te wijzigen. In deze tutorial geven we een inleiding tot wat u moet weten over strings in Java.

## Wat zijn Java-strings en waarvoor worden ze gebruikt?

De programmeertaal Java kent veel verschillende datatypes. De belangrijkste daarvan zijn [Java-primitieven](https://www.ionos.com/nl-be/digitalguide/websites/webontwikkeling/java-primitieven/) zoals integer en char, en complexe datatypes zoals strings. Een string is een **reeks tekens of cijfers** die als object in de klasse java.lang bestaat. Strings worden aangemaakt met de klasse String en kunnen daarna niet meer worden gewijzigd. Desondanks worden Java-strings nog steeds vaker gebruikt dan [StringBuilder](https://www.ionos.com/nl-be/digitalguide/websites/webontwikkeling/java-stringbuilder/), waarmee je strings na het aanmaken kunt wijzigen. Hieronder leggen we uit hoe je een string aanmaakt en welke methoden je tot je beschikking hebt.

## Wat is de syntaxis voor Java-strings?

Als je een nieuwe string wilt maken in Java, kun je deze eenvoudige syntaxis gebruiken:

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

Je geeft aan het systeem door dat je een Java-string wilt maken, geeft de string een naam en voert vervolgens de tekens van de string **tussen de aanhalingstekens** in. Als je later naar die string wilt verwijzen, gebruik je de naam die je eraan hebt gegeven. Hieronder zie je hoe de code voor het maken van een string eruitziet:

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

De uitvoer ziet er als volgt uit:

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

## Welke methoden worden gebruikt bij Java-strings?

Aangezien Java-strings objecten zijn, zijn er verschillende methoden die u kunt gebruiken. Hieronder introduceren we de belangrijkste.

### `length()`

De methode `length()` wordt gebruikt om **het totale aantal tekenwaarden in een tekenreeks weer te geven**. Je krijgt de lengte van je tekenreeks als uitvoer. Hier is de syntaxis:

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

Het is ook heel eenvoudig toe te passen. De code ziet er als volgt uit:

```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.");
 }
}
```

En je krijgt de volgende uitvoer:

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

### `indexOf()`

Je kunt de `indexOf()` gebruiken om **een of meer substrings binnen je grotere string te lokaliseren**. Hier is de syntaxis ervoor:

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

Om de methode te gebruiken, voert u gewoon het deel van de tekenreeks in dat u wilt zoeken.

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

Als uitvoer krijg je de positie waarop die tekst voor het eerst verschijnt:

```java
7
```

### `concat()`

Met `concat()` kun je **twee afzonderlijke strings verbinden** om een nieuwe string te vormen. Hier is de syntaxis:

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

Zo werkt de methode in de praktijk:

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

Dit is de uitvoer:

```java
wordsmith
```

### `equals()`

`equals()` is een van de vele methoden die u kunt gebruiken om Java-strings met elkaar te vergelijken. De methode retourneert een **Booleaanse waarde (waar of onwaar)**. Hier is de syntaxis:

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

In ons voorbeeld maken we drie strings en vergelijken we vervolgens de eerste met de andere twee:

```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));
 }
}
```

Aangezien de eerste en tweede string identiek zijn en de derde niet, krijg je de volgende uitvoer:

```java
true
false
```

### `toUpperCase()` en `toLowerCase()`

De twee methoden `toUpperCase()` en `toLowerCase()` dienen om de tekenwaarden binnen een tekenreeks om te zetten naar **hoofdletters of kleine letters**. Hier is de syntaxis voor elk van hen:

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

Zo werken ze:

```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());
 }
}
```

Dit is de uitvoer:

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

### `split()`

Met de [ Java split()](https://www.ionos.com/nl-be/digitalguide/websites/webontwikkeling/string-splitsen-in-java/) -methode kunt u **een Java-string in kleinere substrings opsplitsen**. Hier is de syntaxis:

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

Zo ziet het er in de praktijk uit:

```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);
		}
	}
}
```

De uitvoer ziet er als volgt uit:

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


This is a markdown version of: [https://www.ionos.com/nl-be/digitalguide/websites/webontwikkeling/java-strings/](https://www.ionos.com/nl-be/digitalguide/websites/webontwikkeling/java-strings/) for AI/LLM consumption.