# Java Strings: Syntax, Funktionsweise und Methoden

Java Strings gehören zu den komplexen [Datentypen in Java](https://www.ionos.com/de-ch/digitalguide/websites/web-entwicklung/java-data-types/). Sie werden genutzt, um eine Abfolge mehrerer Zeichen oder Zahlen abzubilden und zu bearbeiten. Diese Bearbeitung erfolgt mit Hilfe unterschiedlicher Methoden.

## Was sind Java Strings und wozu werden Sie eingesetzt?

Die Programmiersprache Java kennt viele verschiedene Datentypen. Zu den wichtigsten gehören neben [Java Primitives](https://www.ionos.com/de-ch/digitalguide/websites/web-entwicklung/java-primitives/) wie Integer oder char die komplexeren Java Strings. Ein String ist eine **Verkettung von Zeichen oder Ziffern**, die als Objekt in der Klasse java.lang existiert. Sie wird mit der Klasse String erstellt und ist dann final und unabänderlich. Obwohl dies der Fall ist, werden Strings in Java häufiger genutzt als zum Beispiel die Alternative [Java StringBuilder](https://www.ionos.com/de-ch/digitalguide/websites/web-entwicklung/java-stringbuilder/), die sich auch nachträglich bearbeiten lässt. Im Folgenden erklären wir Ihnen, wie ein String gebildet wird und welche Methoden Sie für diesen nutzen können.

## Syntax und Funktionsweise

Wenn Sie einen neuen String in Java erstellen wollen, können Sie dafür auf diese einfache Syntax zurückgreifen:

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

Sie signalisieren dem System also, dass Sie einen Java String erstellen möchten, geben diesem dann einen Namen und hinterlegen danach seine Zeichenwerte **innerhalb der Anführungszeichen**. Beziehen Sie sich zu einem späteren Zeitpunkt wieder auf den String, adressieren Sie ihn bei seinem Namen. So funktioniert die Erstellung in der Praxis:

```java
public class Main {
	public static void main(String[] args) {
	String beispiel = "Dies ist Ihr erster Java String.";
	System.out.println(beispiel);
 }
}
```

Die Ausgabe sieht dann so aus:

```java
Dies ist Ihr erster Java String.
```

## Methoden für Strings in Java

Weil es sich bei Java String um ein Objekt handelt, gibt es verschiedene Methoden, die Sie nutzen können. Die wichtigsten stellen wir Ihnen hier vor.

### length()

Die Methode `length()` wird genutzt, um die **Gesamtzahl der Zeichenwerte in einem String** auszugeben. Als Antwort erhalten Sie also die Länge Ihres Strings. Dies ist die Syntax:

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

Auch die Anwendung ist ganz einfach. Der passende Code sieht so aus:

```java
public class Main {
	public static void main(String[] args) {
	String beispiel = "Dies ist Ihr erster Java String.";
	int length = beispiel.length();
	System.out.println("Der String ist " + length + " Zeichen lang.");
 }
}
```

Dadurch erhalten Sie diese Ausgabe:

```java
Der String ist 32 Zeichen lang.
```

### indexOf()

Die Methode `indexOf()` können Sie nutzen, um ein oder mehrere **Zeichen innerhalb des Java Strings zu lokalisieren**. Dafür nutzen Sie die folgende Syntax:

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

Sie hinterlegen den Teil des Textes, den Sie lokalisieren möchten …

```java
public class Main {
	public static void main(String[] args) {
	String beispiel = "Dies ist Ihr erster Java String.";
	System.out.println(beispiel.indexOf("Ihr"));
 }
}
```

… und erhalten als Ausgabe die Position, an der dieser Teil erstmals im Text auftaucht:

```java
9
```

### concat()

Mit `concat()` **verbinden Sie zwei separate Strings** zu einem neuen String. Dies ist die Syntax:

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

So sieht diese Methode in der Praxis aus:

```java
public class Main {
	public static void main(String[] args) {
	String beispiel = "Beispiel";
	String neuerString = beispiel.concat("sweise");
	System.out.println(neuerString);
 }
}
```

So sieht Ihre neue Ausgabe aus:

```java
Beispielsweise
```

### equals()

`equals()` ist eine von mehreren Methoden, mit denen Sie zwei Java Strings miteinander vergleichen können. Die Methode gibt einen **booleschen Wert (true oder false)** als Ergebnis aus. Dies ist ihre Syntax:

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

Im folgenden Beispiel hinterlegen wir drei Strings und vergleichen den ersten mit den beiden anderen:

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

Da der erste und der zweite String identisch sind und der dritte sich von den beiden anderen Strings unterscheidet, erhalten Sie diese Ausgabe:

```java
true
false
```

### toUpperCase() und toLowerCase()

Die beiden Methoden `toUpperCase()` und `toLowerCase()` dienen dazu, die Zeichenwerte innerhalb eines Java Strings **in Groß- bzw. Kleinbuchstaben umzuwandeln**. Dies ist die jeweilige Syntax:

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

Wir zeigen Ihnen die Funktionsweise beider Methoden in einem Codeausschnitt:

```java
public class Main {
	public static void main(String[] args) {
	String beispiel = "Dies ist Ihr erster Java String.";
	System.out.println(beispiel.toUpperCase());
	System.out.println(beispiel.toLowerCase());
 }
}
```

Sie erhalten diese Ausgabe:

```java
DIES IST IHR ERSTER JAVA STRING.
dies ist ihr erster java string.
```

### split()

Mit der Methode [Java split()](https://www.ionos.com/de-ch/digitalguide/websites/web-entwicklung/java-string-split/) **teilen Sie einen Java String in mehrere Teilstrings**. Dies ist die Syntax:

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

So funktioniert die Methode beispielhaft:

```java
public class Main {
	public static void main(String[] args) {
		String x = "Dies ist Ihr erster Java String";
		String[] ausgabe = x.split(" ");
		for (String y : ausgabe) {
			System.out.println(y);
		}
	}
}
```

Als Ausgabe erhalten Sie dies:

```java
Dies
ist
Ihr
erster
Java
String
```


This is a markdown version of: [https://www.ionos.com/de-ch/digitalguide/websites/web-entwicklung/java-strings/](https://www.ionos.com/de-ch/digitalguide/websites/web-entwicklung/java-strings/) for AI/LLM consumption.