> For the complete documentation index, see [llms.txt](https://educacion.gitbook.io/programacion/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://educacion.gitbook.io/programacion/ud3-introducion-a-programacion-orientada-a-obxectos/clases-da-api-de-java/string.md). # String En Java, a clase `String` é unha das clases máis utilizadas e forma parte do paquete `java.lang`. **Representa cadeas de texto** e, aínda que `String` se comporta como un tipo de datos primitivo, realmente é unha clase que proporciona moitas funcionalidades para traballar con texto. {% hint style="warning" %} **Documentación oficial:** {% endhint %} Aquí tes algunhas características: * **Almacenamento no String Pool**: Java utiliza un *pool* de cadeas (*String Pool*) para gardar instancias de `String`. Cando se crea unha cadea literal, Java comproba se xa existe unha cadea igual no *pool* e, se é así, reutilízaa. Isto axuda a aforrar memoria, especialmente cando se reutilizan cadeas idénticas. ```java String s1 = "Hola"; String s2 = "Hola"; System.out.println(s1 == s2); //true por que son el mismo objeto System.out.println(s1.equals(s2)); //true mismo valor String s3 = new String("Hola"); System.out.println(s1 == s3); // false son objetos diferentes System.out.println(s1.equals(s3)); //true por que tienen el mismo valor //Identificador Hash de objetos System.out.println("ID s1: " + System.identityHashCode(s1)); System.out.println("ID s2: " + System.identityHashCode(s2)); System.out.println("ID s3: " + System.identityHashCode(s3)); ``` * **Inmutabilidade**: Unha vez que unha instancia de `String` é creada, non pode ser modificada. Calquera operación que aparentemente modifique unha cadea (como concatenación) crea unha nova instancia de `String`, e a antiga permanece inalterada. Por exemplo: ```java String texto = "Hola"; System.out.println("ID texto: " + System.identityHashCode(texto)); texto = texto + "mundo"; System.out.println("ID texto: " + System.identityHashCode(texto)); ``` O contido orixinal “Ola” non é alterado; a variable `texto` agora referencia unha nova cadea “Ola Mundo”. ## Métodos máis utilizados A clase `String` proporciona moitos métodos útiles para manipular cadeas de texto. Aquí tes algúns dos máis comúns: * **Crear unha instancia de `String`** ```java String sb = new String(); // Cadea baleira String sbCoTexto = new String("Ola Mundo"); // Cadea inicial ``` * **Obter un carácter nunha posición concreta**: `char charAt(int index)` ```java char caracter = texto.charAt(4); // Obtense o caracter da posición 4 ``` * **Concatenar cadeas**: `concat(String str)` ```java String parte1 = "Ola"; String parte2 = " Mundo"; String resultado = parte1.concat(parte2); // Retorna "Ola Mundo" ``` * **Comprobar se unha cadea de texto contén unha determinada subcadea**: `boolean contains(CharSequence subcadea)` ```java String texto = "Ola, benvido a Java!"; System.out.println(texto.contains("benvido")); // true System.out.println(texto.contains("Python")); // false ``` * **Comprobar se unha cadea de texto remata cunha determinada subcadea** : `boolean endsWith(String sufixo)` ```java String ficheiro = "documento.pdf"; System.out.println(ficheiro.endsWith(".pdf")); // true System.out.println(ficheiro.endsWith(".txt")); // false ``` * **Comparar cadeas**: `boolean equals(String str)` e `boolean equalsIgnoreCase(String str)` ```java String a = "Ola"; String b = "ola"; boolean igual = a.equals(b); // Retorna false boolean igualIgnorandoMaiusculas = a.equalsIgnoreCase(b); // Retorna true ``` * **Buscar caracteres ou subcadeas**: `int indexOf(int caracter)`, `int indexOf(int caracter, int dendeIndice)`, `int indexOf(int caracter, int dendeIndice, int ataIndice)`, `int indexOf(String cadea)`, `int indexOf(String cadea, int dendeIndice)`, `int indexOf(String cadea, int dendeIndice, int ataIndice)` ```java String texto = "Benvido ao curso de Java"; int indice = texto.indexOf("curso"); // Retorna 11 ``` * **Obter o longo da cadea**: `int length()` ```java String texto = "Exemplo"; int longo = texto.length(); // Retorna 7 ``` * **Reemplazar Caracteres ou Subcadeas**: `String replace(char caracter, char caracterNovo)` e `String replace(String subcdea, char subcadeaNova)` ```java String texto = "Java é divertido"; String resultado = texto.replace("divertido", "incrible"); // Retorna "Java é incrible" ``` * **Dividir Cadeas**: `String[] split(String regex)` ```java String texto = "Ola, Mundo"; String[] partes = texto.split(", "); // Retorna un array ["Ola", "Mundo"] ``` * **Comprobar se unha cadea de texto comeza cunha determinada subcadea** : `boolean startsWith(String prefixo)` ```java String ficheiro = "documento.pdf"; System.out.println(ficheiro.startsWith("doc")); // true System.out.println(ficheiro.startsWith("txt")); // false ``` * **Subcadeas**: `String substring(int indiceComezo)` e `String substring(int indiceComezo, int indiceFinalsinIncluir)` ```java String texto = "Benvido"; String subcadea = texto.substring(3); // Retorna "vido" ``` * **Conversións a maiúsculas ou minúsculas**: `String toUpperCase()` e `String toLowerCase()` ```java String texto = "Ola Mundo"; String maiusculas = texto.toUpperCase(); // Retorna "OLA MUNDO" ``` * **Eliminar espazos en branco ao principio e final**: `String trim()` ```java String texto = " Ola "; String senEspazos = texto.trim(); // Retorna "Ola" ``` ## Conversión a String O método `valueOf()` da clase `String` en Java é un método estático que converte diferentes tipos de datos en **cadeas de texto (`String`****)**. ```java public static String valueOf(tipo valor) ``` A clase `String` sobrecarga `valueOf()` para admitir diferentes tipos de datos: | Método | Conversión | Exemplo | | ---------------------------------------------------------- | ----------------------------------------------- | ------------------------------------------------------------------- | | `String.valueOf(int i)` | `int → String` | `String.valueOf(42)` | | `String.valueOf(double d)` | `double → String` | `String.valueOf(3.14)` | | `String.valueOf(boolean b)` | `boolean → String` | `String.valueOf(true)` | | `String.valueOf(char c)` | `char → String` | `String.valueOf('A')` | | `String.valueOf(char[] data)` | `char[] → String` | `String.valueOf(new char[]{'H', 'o'})` | ## Conversión dende String Para converter un `String` a outros tipos de datos en Java, utilizamos os métodos de conversión proporcionados polas clases envolventes (`wrapper classes`) dos tipos primitivos. | Conversión | Método | | ------------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------- | | `String` → `int` | `Integer.parseInt(str)` ou `Integer.valueOf(str)` | | `String` → `double` | `Double.parseDouble(str)` ou `Double.valueOf(str)` | | `String` → `boolean` | `Boolean.parseBoolean(str)` ou `Boolean.valueOf(str)` | | `String` → `char[]` | `str.toCharArray()` | A diferenza de `parseX()`, `valueOf()` devolve obxectos envolventes como `Integer`, `Double`, `Boolean`, etc., mentres que `parseX()` devolve tipos primitivos como `int`, `double`, etc. **Importante:** Todas as conversións numéricas lanzan unha **`NumberFormatException`** se o `String` non contén un valor válido. ### Conversion de caracteres a enteiros Se utilizamos o método `Integer.valueOf(char)` por exemplo co caracter `'9'`, este método non devolverá o enteiro `9`, senón que devolverá o seu código ASCII correspondente 57. ```java int numero = Integer.valueOf('9'); System.out.println(numero); // Imprime 57 ``` A solución é, ou pasalo carácter a un `String`: ```java String numeroS = String.valueOf('9'); int numero = Integer.valueOf(numeroS); System.out.println(numero); // Imprime 9 ``` ## Comparacións de cadeas En Java, comparar cadeas de texto (`String`) pode facerse de varias formas, dependendo de que queres comprobar exactamente (se as cadeas son iguais, se unha é lexicograficamente maior que a outra, etc.). Aquí te explico as principais formas de comparar `String` en Java: * O método **`boolean equals(Object outro)`** compara o **valor** das cadeas, é dicir, o contido das cadeas. ```java String a = "Java"; String b = "Java"; String c = "java"; System.out.println(a.equals(b)); // true System.out.println(a.equals(c)); // false ``` * `boolean equalsIgnoreCase(String outro)` este método compara as cadeas sen ter en conta se son maiúsculas ou minúsculas. ```java String a = "Java"; String b = "java"; System.out.println(a.equalsIgnoreCase(b)); // true ``` * Se necesitas comparar cadeas para ver se son **maiores**, **menores** ou **iguales** en orde lexicográfica, usa **`int compareTo(String outro)`**. Retorna un número negativo, cero ou positivo dependendo de se a cadea actual é lexicograficamente menor, igual ou maior que a cadea de comparación. ```java String a = "Java"; String b = "Python"; String c = "Java"; System.out.println(a.compareTo(b)); // Valor negativo (porque "Java" é lexicograficamente menor que "Python") System.out.println(a.compareTo(c)); // 0 (porque son iguais) System.out.println(b.compareTo(a)); // Valor positivo (porque "Python" é lexicograficamente maior que "Java") ``` * Para non distinguir entre maiúsculas e minúsculas, usa **`int compareToIgnoreCase(String outro)`**. ```java String a = "java"; String b = "Java"; System.out.println(a.compareToIgnoreCase(b)); // 0 (porque non importa a maiúscula/minúscula) ``` Comparación == O operador **`==`** compara as referencias dos obxectos, non os seus valores. Isto significa que **compara se as cadeas son o mesmo obxecto na memoria**, non se teñen o mesmo contido. #### Exemplo: ```java String a = "Java"; String b = "Java"; String c = new String("Java"); System.out.println(a == b); // true (porque "Java" está na área de memoria do "String pool") System.out.println(a == c); // false (porque "c" é un novo obxecto na memoria) ``` --- # Agent Instructions This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com. ## Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter: ``` GET https://educacion.gitbook.io/programacion/ud3-introducion-a-programacion-orientada-a-obxectos/clases-da-api-de-java/string.md?ask= ``` The question should be specific, self-contained, and written in natural language. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.