# Java Strings: sintaxe, funcionamento e métodos

As strings Java pertencem aos [tipos de dados](https://www.ionos.com/pt-pt/digitalguide/paginas-web/desenvolvimento-web/tipos-de-dados-java/) complexos. São utilizadas para construir uma sequência de vários caracteres ou números e podem ser processadas através de vários métodos.

## O que são strings em Java e para que servem?

A linguagem de programação Java dispõe de muitos tipos de dados diferentes. Entre os mais importantes estão os [primitivos de Java](https://www.ionos.com/pt-pt/digitalguide/paginas-web/desenvolvimento-web/primitivos-de-java/), como Integer ou char, ou as strings complexas. Uma string é uma **concatenação de números e caracteres** que existe como objeto na classe java.lang. São criadas com a classe String e são definitivas e imutáveis. Mesmo assim, as strings Java são utilizadas com mais frequência do que, por exemplo, a alternativa, os [StringBuilders Java](https://www.ionos.com/pt-pt/digitalguide/paginas-web/desenvolvimento-web/java-stringbuilder/), que podem ser editados posteriormente. A seguir, explicamos como criar uma string e quais métodos pode utilizar para o fazer.

## Sintaxe e funcionamento

Para criar uma string em Java, pode seguir esta sintaxe tão simples:

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

Assim, indica ao sistema que deseja criar uma string Java, atribui-lhe um nome e armazena os seus valores numéricos **entre aspas**. Desta forma, se mais tarde quiser fazer referência à string, pode chamá-la pelo seu nome. Aqui está um exemplo de como se cria uma string:

```java
public class Main {
	public static void main(String[] args) {
	String ejemplo = "Este es tu primer string en Java.";
	System.out.println(ejemplo);
 }
}
```

Você recebe o seguinte:

```java
Este es tu primer string en Java.
```

## Métodos para strings Java

Embora uma string seja um objeto, você pode usar muitos métodos. Apresentamos abaixo os mais importantes.

### `length()`

O método `length()` é usado para refletir o **número total de caracteres de uma string** e fornece como resposta o comprimento da cadeia. Esta é a sua sintaxe:

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

Também é muito fácil de usar. O código correspondente é o seguinte:

```java
public class Main {
	public static void main(String[] args) {
	String ejemplo = "Este es tu primer string en Java.";
	int length = ejemplo.length();
	System.out.println("El string consta de " + length + " caracteres.");
 }
}
```

Desta forma, obtém-se o seguinte:

```java
El string consta de 33 caracteres.
```

### `indexOf()`

O método `indexOf()` pode ser utilizado para **localizar um ou vários caracteres dentro de uma string Java**. Utilize-o com a seguinte sintaxe:

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

Indique a parte do texto que deseja localizar:

```java
public class Main {
	public static void main(String[] args) {
	String ejemplo = "Este es tu primer string en Java.";
	System.out.println(ejemplo.indexOf("tu"));
 }
}
```

E receberá como resultado a posição em que o fragmento aparece pela primeira vez no texto:

```java
9
```

### `concat()`

`concat()` serve para **ligar duas strings diferentes** numa nova. Esta é a sintaxe:

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

Como usar o método na prática:

```java
public class Main {
	public static void main(String[] args) {
	String ejemplo = "Por";
	String nuevoString = ejemplo.concat(" ejemplo");
	System.out.println(nuevoString);
 }
}
```

E é devolvido a si:

```java
Por ejemplo
```

### `equals()`

`equals()` é um dos muitos métodos que permitem comparar strings em Java. O método fornece como resultado um \*\*valor booleano (true ou false). A sintaxe é:

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

No exemplo seguinte, armazenamos três strings e comparamos a primeira com as outras duas:

```java
public class Main {
	public static void main(String[] args) {
	String primerString = "ABC";
	String segundoString = "ABC";
	String tercerString = "DEF";
	System.out.println(primerString.equals(segundoString));
	System.out.println(priemerString.equals(tercerString));
 }
}
```

Como a primeira e a segunda string são idênticas, e a terceira é diferente, o resultado é:

```java
true
false
```

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

Os dois métodos `toUpperCase()` e `toLowerCase()` servem para **alternar entre maiúsculas e minúsculas**. Utiliza-se a seguinte sintaxe:

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

Veja como ambos os métodos funcionam no seguinte fragmento de código:

```java
public class Main {
	public static void main(String[] args) {
	String ejemplo = "Este es tu primer string en Java.";
	System.out.println(ejemplo.toUpperCase());
	System.out.println(ejemplo.toLowerCase());
 }
}
```

Recebes:

```java
ESTE ES TU PRIMER STRING EN JAVA.
este es tu primer string en java.
```

### `split()`

Com o método [Java split()](https://www.ionos.com/pt-pt/digitalguide/paginas-web/desenvolvimento-web/divisao-de-cadeias-de-caracteres-java/), **divide-se uma string em várias subcadeias**. Esta é a sintaxe:

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

Aqui está um exemplo de como funciona o método:

```java
public class Main {
	public static void main(String[] args) {
		String x = "Este es tu primer string en Java";
		String[] ausgabe = x.split(" ");
		for (String y : ausgabe) {
			System.out.println(y);
		}
	}
}
```

A resposta é:

```java
Este
es
tu
primer
string
en
Java
```


This is a markdown version of: [https://www.ionos.com/pt-pt/digitalguide/paginas-web/desenvolvimento-web/strings-java/](https://www.ionos.com/pt-pt/digitalguide/paginas-web/desenvolvimento-web/strings-java/) for AI/LLM consumption.