# Stringhe Java: sintassi, funzionamento e metodi

Le stringhe di Java fanno parte dei [tipi di dati](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/tipi-di-dati-in-java/) complessi e servono a creare ed elaborare sequenze di simboli o numeri. I metodi usati a questo scopo sono numerosi.

## A cosa servono le stringhe Java e come si usano?

Il [liguaggio di programmazione](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/linguaggi-programmazione-web/) Java ammette diversi tipi di dati. Fra quelli più importanti, oltre ai dati [primitivi di Java](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/tipi-primitivi-di-java/) (ad esempio integer o char), esistono anche stringhe più complesse. Una stringa è una **sequenza di caratteri o cifre** che esiste nella classe java.lang in qualità di oggetto. Si crea mediante la classe String, e una volta generata non può più essere modificata. Anche se [Java StringBuilder](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/stringbuilder-in-java/) consente di modificare le stringhe in un secondo momento, queste vengono create più spesso come segue. In questo articolo ti spieghiamo come si crea una stringa e qual è il metodo più adeguato da usare.

## Sintassi e funzionamento

Se desideri creare una nuova stringa in Java, puoi ricorrere a questa semplice sintassi:

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

Il sistema riceve l’input per creare una stringa Java, assegnando a questa un nome e memorizzando i valori dei suoi caratteri **all’interno delle virgolette**. Nel caso in cui si desideri fare riferimento alla stringa in un secondo momento, basta digitarne il nome. Nella pratica il codice si scrive così:

```java
public class Main {
	public static void main(String[] args) {
	String esempio = "Questa è la tua prima stringa in Java";
	System.out.println(esempio);
 }
}
```

L’output è il seguente:

```java
Questa è la tua prima stringa in Java
```

## Metodi per le stringhe di Java

Poiché una stringa Java è un oggetto, esistono numerosi metodi per usarla. Di seguito ti presentiamo i più importanti.

### `length()`

Il metodo `length()` viene usato per ottenere un determinato **numero di valori in una stringa**. Il risultato sarà la lunghezza della stringa. Questa è la sintassi:

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

L’applicazione del metodo è altrettanto semplice. Questo il relativo codice:

```java
public class Main {
	public static void main(String[] args) {
	String esempio = "Questa è la tua prima stringa in Java";
	int length = esempio.length();
	System.out.println("La stringa è lunga" + length + "caratteri.");
 }
}
```

Questo l’output che si ottiene:

```java
La stringa è lunga 32 caratteri.
```

### `indexOf()`

Puoi ricorrere al metodo `indexOf()` per **individuare la posizione di uno o più caratteri all’interno della stringa Java**. Per farlo puoi usare questa sintassi:

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

Scrivi la parte del testo che desideri localizzare …

```java
public class Main {
	public static void main(String[] args) {
	String esempio = "Questa è la tua prima stringa in Java";
	System.out.println(esempio.indexOf("tua"));
 }
}
```

… e come output ottieni la posizione in cui compare la porzione di testo:

```java
9
```

### `concat()`

Con `concat()` puoi **unire due stringhe separate** in una singola stringa. La sintassi è la seguente:

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

Nella pratica il metodo si scrive così:

```java
public class Main {
	public static void main(String[] args) {
	String esempio = "esem";
	String nuovaString = esempio.concat("pio");
	System.out.println(nuovaString);
 }
}
```

L’output è il seguente:

```java
esempio
```

### `equals()`

`equals()` è uno dei tanti metodi che ti consentono di [mettere a confronto le stringhe Java](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/java-string-compare/). L’output di questo metodo è un **valore booleano (vero o falso)**. Questa è la sintassi:

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

Nell’esempio seguente digiti due stringhe e confronti la prima con la seconda:

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

Poiché la prima e la seconda stringa sono identiche e la terza stringa differisce dalle altre due, ottieni il seguente output:

```java
true
false
```

### `toUpperCase()` e `toLowerCase()`

I due metodi `toUpperCase()` e `toLowerCase()` servono a trasformare i valori dei caratteri all’interno della stringa Java **in caratteri maiuscoli e minuscoli**. Questa la relativa sintassi:

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

In questo snippet di codice ti mostriamo come funzionano entrambi i metodi:

```java
public class Main {
	public static void main(String[] args) {
	String esempio = "Questa è la tua prima stringa in Java";
	System.out.println(esempio.toUpperCase());
	System.out.println(esempio.toLowerCase());
 }
}
```

L’output è il seguente:

```java
QUESTA È LA TUA PRIMA STRINGA IN JAVA
questa è la tua prima stringa in java.
```

### `split()`

Con il metodo [Java split()](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/java-string-split/) **suddividi una stringa Java in più sottostringhe**. Questa è la sintassi:

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

Il metodo funziona così:

```java
public class Main {
	public static void main(String[] args) {
		String x = "Questa è la tua prima stringa in Java";
		String[] output = x.split(" ");
		for (String y : output) {
			System.out.println(y);
		}
	}
}
```

L’output che ottieni è il seguente:

```java
Questa
è
la
tua
prima
stringa
in
Java
```


This is a markdown version of: [https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/java-string/](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/java-string/) for AI/LLM consumption.