# Java Strings: sintaxis, funcionamiento y métodos

Los strings de Java pertenecen a los [tipos de datos](https://www.ionos.com/es-us/digitalguide/paginas-web/desarrollo-web/java-data-types/) complejos. Se utilizan para construir una secuencia de múltiples caracteres o cifras y pueden procesarse gracias a diversos métodos.

## ¿Qué son los strings de Java y para qué se utilizan?

El [lenguaje de programación](https://www.ionos.com/es-us/digitalguide/paginas-web/desarrollo-web/lenguajes-de-programacion-web/) Java dispone de muchos tipos de datos diferentes. Entre los más importantes están los [primitivos de Java](https://www.ionos.com/es-us/digitalguide/paginas-web/desarrollo-web/primitivos-de-java/) como Integer o char, o los strings complejos. Un string es una **concatenación de cifras y caracteres** que existe como objeto en la clase java.lang. Se crean con la clase String y son definitivos e inmutables. Aun así, los strings de Java se utilizan con más frecuencia que por ejemplo la alternativa, los [StringBuilders de Java](https://www.ionos.com/es-us/digitalguide/paginas-web/desarrollo-web/java-stringbuilder/), que sí pueden editarse a posteriori. A continuación, te explicamos cómo se crea un string y qué métodos puedes usar para hacerlo.

## Sintaxis y funcionamiento

Para crear un string en Java, puedes seguir esta sintaxis tan sencilla:

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

Así, indicas al sistema que quieres crear un string de Java, le das un nombre y almacenas sus valores numéricos **dentro de las comillas**. De esta manera, si más tarde quieres hacer referencia al string, puedes llamarlo por su nombre. He aquí un ejemplo de cómo se crea un string:

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

Se te devuelve lo siguiente:

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

## Métodos para los strings de Java

Aunque un string es un objeto, puedes usar muchos métodos. Te presentamos abajo los más importantes.

### `length()`

El método `length()` se usa para reflejar el **número total de caracteres de un string**, y te ofrece como respuesta la longitud de la cadena. Esta es su sintaxis:

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

También es muy fácil de utilizar. El código correspondiente es el siguiente:

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

De esta manera se obtiene lo siguiente:

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

### `indexOf()`

El método `indexOf()` puede utilizarse para **localizar uno o varios caracteres dentro de un string de Java**. Úsalo con la siguiente sintaxis:

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

Indica la parte del texto que quieres 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"));
 }
}
```

Y recibirás como resultado la posición en la que aparece por primera vez el fragmento en el texto:

```java
9
```

### `concat()`

`concat()` sirve para **vincular dos strings distintos** en uno nuevo. Esta es la sintaxis:

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

Así se usa el método en la práctica:

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

Y se te devuelve:

```java
Por ejemplo
```

### `equals()`

`equals()` es uno de los muchos métodos que permiten comparar strings de Java. El método ofrece como resultado un \*\*valor booleano (true o false). La sintaxis es:

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

En el siguiente ejemplo, almacenamos tres strings y comparamos el primero con los otros dos:

```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 el primer y el segundo string son idénticos, y el tercero es diferente, el resultado es:

```java
true
false
```

### `toUpperCase()` y `toLowerCase()`

Los dos métodos `toUpperCase()` y `toLowerCase()` sirven para **cambiar entre mayúsculas y minúsculas**. Se usa la siguiente sintaxis:

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

Verás cómo funcionan ambos métodos en el siguiente 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());
 }
}
```

Recibes:

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

### `split()`

Con el método de [Java split()](https://www.ionos.com/es-us/digitalguide/paginas-web/desarrollo-web/java-string-split/) **divides un string en múltiples subcadenas**. Esta es la sintaxis:

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

He aquí un ejemplo de cómo funciona el 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);
		}
	}
}
```

La respuesta es:

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


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