Métodos básicos de la clase String
La clase
String se encuentra en java.lang, paquete que viene precargado en Java.
Un String en
Java representa una cadena de caracteres no modificable. Esto quiere decir que
para combinar 2 de su tipo, Java crea un tercero con la suma de las 2
dimensiones y después agrega el primer String
y luego el otro.
A todo tipo
de dato que se le agregue comillas dobles se implementan como objetos de la
clase String.
En esta entrada se verán varios métodos, siendo una entrada al blog algo extensa pero que contiene información valiosa para el programador.
*La mayoría de los métodos usados si no son manejados correctamente arrojan excepciones.
Métodos
------------------------------------------------------------------------------------------------------------------
- charAt(int índice).
Método que
recibe un número entero, el cual es el número del carácter que se desea
obtener.
*Indexado en
0 [cero].
String prueba
= “Hola”;
prueba.charAt(0)
= Retorna el carácter [ H ].
prueba.charAt(2)
= Retorna el carácter [ l ].
------------------------------------------------------------------------------------------------------------------
- codePointAt(int índice).
Recibe un
número entero el cual es el número del carácter que se desea obtener y retorna
el valor del carácter en ASCII.
String prueba
= “Hola”;
Ejemplo 1:
codePointAt (0) = Retorna el número 72
que en la tabla ASCII es el carácter [H].
Ejemplo 2:
codePointAt (2) = Retorna el número
111 que en la tabla ASCII es el carácter
[o].
------------------------------------------------------------------------------------------------------------------
- codePointBefore (int índice).
Devuelve el
valor del carácter en ASCII antes de que el índice especificado.
String prueba
= “Hola”;
Ejemplo :
codePointBefore (1) = Retorna el
número 72 que en la tabla ASCII es el carácter
[H].
------------------------------------------------------------------------------------------------------------------
- compareTo(String cadena):
Permite comparar dos cadenas de
caracteres. Distingue mayúsculas y minúsculas.
Retorna un valor entero.
+ Si el valor es cero (0), las
dos cadenas son iguales.
+ Si el valor es entero
positivo, el String que invoca es mayor.
+ Si el valor es entero
negativo, el String que invoca es menor.
(string_invoca).compareTo(string_invocado)
Ejemplo 1:
String cadena1 = "Hola Mundo";
String cadena2 = cadena1;
int resultado
= cadena1.compareTo(cadena2);
resultado =
0;
Ejemplo 2:
String cadena1 = “Hola Mundo”;
String cadena2 = “hola mundo”;
cadena1.compareTo(cadena2);
int resultado
= cadena1.compareTo(cadena2);
resultado =
1.
------------------------------------------------------------------------------------------------------------------
- compareToIgnoreCase(String cadena):
Al igual que la anterior, pero
no tiene en cuenta mayúsculas o minúsculas. Retorna lo mismo que el método anterior.
Ejemplo:
String cadena1 = “Hola Mundo”;
String cadena2 = “hola mundo”;
cadena1.compareTo(cadena2);
int resultado
= cadena1.compareTo(cadena2);
resultado =
0.
------------------------------------------------------------------------------------------------------------------
- equals(String cadena):
Sirve para comparar dos cadenas,
compara el contenido de los objetos.
Retorna booleano true – false.
El resultado tiene en cuenta si
la cadena esta en mayúsculas-minúsculas e inclusive los espacios para retornar
el veredicto. *El programador tiene que tener en cuenta esto.
string1.equals(string2);
Ejemplo:
String cadena1 = “Hola Mundo”;
String cadena2 = “hola mundo”;
boolean respuesta = cadena1.equals(cadena2);
respuesta =
false;
------------------------------------------------------------------------------------------------------------------
- equalsIgnoreCase(String cadena):
Sirve para comparar dos
cadenas, pero no tiene en cuenta mayúscula o minúscula.
Retorna booleano true – false.
String cadena1 = “Hola Mundo”;
String cadena2 = “hola mundo”;
boolean respuesta = cadena1.equals(cadena2);
respuesta =
true;
------------------------------------------------------------------------------------------------------------------
- indexOf(String cadena):
Busca
un carácter o un grupo de caracteres en una cadena en una posición inicial.
Retorna
el índice donde comienza el carácter-grupo de caracteres en la cadena.
Retorna
-1 si no se encuentra la cadena solicitada en el String.
String
cadena1 = "Hola Mundo";
String
buscar = "Mun";
int
resultado = cadena1.indexOf(buscar);
resultado
= 5;
------------------------------------------------------------------------------------------------------------------
- indexOf(char letra):
Busca
un carácter en una cadena en una posición inicial.
Retorna
el índice donde comienza el carácter en la cadena.
Retorna
-1 si no se encuentra el carácter solicitado en el String.
String
cadena1 = "Hola Mundo";
char
letraBuscar = 'n';
int
resultado = cadena1.indexOf(letraBuscar);
resultado
= 7 ;
------------------------------------------------------------------------------------------------------------------
- indexOf( String cadena , int índice):
Busca
un carácter o un grupo de caracteres en una cadena en una posición inicial.
+
Mandando el String que se va a buscar y un entero, se tomara al entero como un
índice, donde comenzara la búsqueda del String.
Retorna
el índice donde comienza el carácter-grupo de caracteres en la cadena.
Retorna
-1 si no se encuentra la cadena solicitada en el String.
String
cadena1 = "Hola Mundo";
String
letraBuscar = "un";
int
indice = 3;
int
resultado = cadena1.indexOf(letraBuscar,indice);
resultado
= 6 ;
------------------------------------------------------------------------------------------------------------------
- indexOf( char letra , int índice):
Busca un carácter en una cadena en una posición inicial.
+ Mandando el char que se va a buscar y un entero, se tomara al segundo entero como un índice, donde comenzara la búsqueda del carácter.
Retorna el índice donde comienza el carácter en la cadena.
Retorna -1 si no se encuentra el carácter solicitado en el String.
String cadena1 = "Hola Mundo";
String letraBuscar = "un";
int indice = 3;
int resultado = cadena1.indexOf(letraBuscar,indice);
resultado = 6 ;
------------------------------------------------------------------------------------------------------------------
- lastIndexOf(String cadena):
Busca un carácter o un grupo de
caracteres en una cadena en una posición final.
Retorna el último índice donde
comienza el carácter-grupo de caracteres en la cadena.
Retorna -1 si no se encuentra
la cadena solicitada en el String.
String cadena1 = "Hola
Mundo";
String buscar =
"Mun";
int resultado =
cadena1.indexOf(buscar);
resultado = 5;
------------------------------------------------------------------------------------------------------------------
- lastIndexOf(char letra):
Busca un carácter en una cadena
en una posición final.
Retorna el último índice donde
comienza el carácter en la cadena.
Retorna -1 si no se encuentra
la cadena solicitada en el String.
String cadena1 = "Hola
Mundo";
char buscar = ‘o’;
int resultado =
cadena1.indexOf(buscar);
resultado = 9;
------------------------------------------------------------------------------------------------------------------
- lastIndexOf ( String cadena , int índice):
Busca
un carácter o un grupo de caracteres en una cadena en una posición final.
+
Mandando el String que se va a buscar y un entero, se tomara al entero como un
índice buscando hacia atrás, empezando en el índice especificado.
Retorna
el último índice donde comienza el carácter-grupo de caracteres en la cadena.
Retorna
-1 si no se encuentra la cadena solicitada en el String.
String
cadena1 = "Hola Mundo";
String
letraBuscar = "un";
int
indice = 3;
int
resultado = cadena1.indexOf(letraBuscar,indice);
resultado
= 6 ;
------------------------------------------------------------------------------------------------------------------
- lastIndexOf ( char letra , int índice):
Busca
un carácter en una cadena en una posición final.
+
Mandando el char que se va a buscar y un entero, se tomara al segundo entero
como un índice buscando hacia atrás, empezando en el índice especificado.
Retorna
el último índice donde comienza el carácter en la cadena.
Retorna
-1 si no se encuentra el carácter solicitado en el String.
String
cadena1 = "Hola Mundo";
char
letraBuscar = ‘o’;
int
indice = 3;
int
resultado = cadena1.indexOf(letraBuscar,indice);
resultado
= 9 ;
------------------------------------------------------------------------------------------------------------------
- length():
Retorna la longitud de una
cadena, un número que es el número total de caracteres que contiene la cadena.
String cadena=”Hola Mundo”
int longitud =cadena.length();
longitud =10.
------------------------------------------------------------------------------------------------------------------
- matches(String regex):
Retorna true – false si la
cadena coincide con la expresión regular recibida.
String
cadena=”1234543AB”;
String regex =
“[0-9]+”;
boolean resultado = cadena.matches(regex);
resultado = false;
------------------------------------------------------------------------------------------------------------------
- replace( String cadena1 , String cadena2):
Reemplaza un carácter por otro
carácter en una cadena. Puede aplicarse para remplazar una cadena por otra.
Retorna un nuevo String con las
modificaciones correspondientes.
String cadena = "Hola Mundo";
String letraQuitar = "o";
String letraNueva =
"a";
String cadena2 = cadena.replace(letraQuitar, letraNueva);
cadena2 = Hala
Munda;
------------------------------------------------------------------------------------------------------------------
- replaceAll (String regex , String cadena2):
Reemplaza cada subcadena de
esta cadena que coincide con la expresión regular dada con el reemplazo dado.
Retorna un nuevo String con las
modificaciones correspondientes.
String cadena = "Hola Mundo Mundo Mundo";
String cadenaQuitar = "Mundo";
String cadenaNueva = "";
String cadena2 = cadena.replaceAll(cadenaQuitar, cadenaNueva);
cadena2 :
Hola___ ;
*Los _ se ocupa para representar los espacios que se dejo cuando se remplazo la cadena. Se tiene que tener en cuenta eso a la hora de remplazar las cosas.
------------------------------------------------------------------------------------------------------------------
- substring( int índice):
Retorna una nueva cadena a
partir de otra cadena.
+ Mandando como parámetro
solamente un entero, el entero se toma como un índice y retorna desde el índice
hasta el final de la cadena.
String cadena = "Hola_Mundo";
int index = 4;
String resultado = cadena.substring(index);
resultado = _Mundo;
------------------------------------------------------------------------------------------------------------------
- substring ( int índice1 , int índice2):
Retorna una nueva cadena a
partir de otra cadena.
+ Mandando como parámetro 2
enteros, se retorna una cadena tomando como índice el primer entero hasta el
segundo entero enviado.
String cadena = "Hola_Mundo";
int index = 4;
int endIndex = 9;
String resultado = cadena.substring(index,
endIndex);
resultado = _Mund;
------------------------------------------------------------------------------------------------------------------
- toCharArray():
Convierte una cadena de
caracteres en un arreglo tipo char.
Retorna arreglo de caracteres.
String cadena =
"Hola_Mundo";
char [ ] resultado = cadena.toCharArray();
resultado = [H, o, l, a, _,
M, u, n, d, o];
------------------------------------------------------------------------------------------------------------------
- startsWith( String cadena):
Busca si una cadena inicia con
una cadena especifica.
Retorna true – false.
Tener cuidado por que distingue
entre mayúsculas y minúsculas.
+ Al recibir una cadena busca
si en la cadena que se invoca se encuentra la cadena recibida.
String cadena1 = "Hola
Mundo";
String iniciar = "H";
boolean resultado = cadena1.startsWith(iniciar);
resultado = true;
------------------------------------------------------------------------------------------------------------------
- startsWith( String cadena , int índice):
Busca si una cadena inicia con
una cadena especifica.
Retorna true – false.
Tener cuidado por que distingue
entre mayúsculas y minúsculas.
+ Al recibir una cadena y un
entero, busca si en la cadena se encuentra la cadena recibida desde el entero
recibido que se toma como un índice.
String cadena1 = "Hola
Mundo";
String iniciar = "u";
int index = 6;
boolean resultado = cadena1.startsWith(iniciar, index);
resultado = true;
------------------------------------------------------------------------------------------------------------------
- endsWith( String cadena) :
Busca si una cadena termina con
una cadena especifica.
Retorna true – false.
Tener cuidado, distingue entre
mayúsculas y minúsculas.
String cadena1 = "Hola
Mundo";
String iniciar = "o";
boolean resultado = cadena1.endsWith(iniciar);
resultado = true;
------------------------------------------------------------------------------------------------------------------
- toLowerCase():
Convierte una cadena a minúsculas.
Retorna un String con las
modificaciones correspondientes.
String cadena1 = "Hola
Mundo";
String resultado = cadena1.toLowerCase();
resultado = hola mundo;
------------------------------------------------------------------------------------------------------------------
- toUpperCase ():
Convierte una cadena a Mayúsculas.
Retorna un String con las
modificaciones correspondientes.
String cadena1 = "Hola
Mundo";
String resultado = cadena1.toUpperCase();
resultado = HOLA MUNDO;
------------------------------------------------------------------------------------------------------------------
- trim():
Retorna un String con los
espacios finales e iniciales eliminados.
String cadena1 = " Hola Mundo ";
String resultado = cadena1.trim();
resultado = “Hola Mundo”;
------------------------------------------------------------------------------------------------------------------
Con
esto finaliza los métodos básicos de la clase String, teniendo en
cuenta que son de gran ayuda para el programador en diferentes situaciones.
Para mayor información consulten la página oficial de Oracle, en el siguiente link: Clase String
Por
su atención Muchas Gracias.
Estoy a su disposición para cualquier duda o
aclaración.
