Primitivos | boolean | true/false | |
byte | 8 bits | -128 a 127 | |
char | 16 bits | Carácteres UNICODE.Los carácteres se encierran entre comillas simples (Ejemplo: ‘a’, ‘b’, ‘c’). | |
int | 32 bits | -2,147,483,648 a 2,147,483,647. | |
color | 32 bits | AAAAAAAARRRRRRRRGGGGGGGGBBBBBBBB donde las A representan el valor del canal ALFA, las R son el valor rojo/tinte, las G son el verde/saturación y las B son el azul/brillo.Internamente es manejado como un int en MobileProcessing. | |
Compuestos | Array | Son listas finitas de elementos del mismo tipo.Ejemplo: tipo[] arreglo = new tipo[tamaño];
Los elementos del arreglo son referenciados por índices que empiezan en cero y van hasta la longitud del arreglo – 1. |
|
Object | Los objetos son instancias de clases, tienen métodos y atributos. Las instancias se crean con el operador new. | ||
String | Son secuencias de carácteres. La clase String incluye múltiples métodos para su manipulación. |
Conversión a String.
La conversión desde un tipo primitivo hacia String se realiza mediante la función str(valor).
boolean b = true;
byte y = -120;
char c = 'J';
float f = -64.9;
int i = 1024;
String sb = str(b);
String sy = str(y);
String sc = str(c);
String sf = str(f);
String si = str(i);
Funciones y métodos de la clase String.
A continuación se explican las funciones que incluye el lenguaje para el manejo de cadenas.
join(arreglo, separador) | Combina un arreglo en una cadena uniéndolo con el separador. |
int arreglo = new int[3];
arreglo[0] = 100;
arreglo[1] = 200;
arreglo[2] = 300;
String resultado = join(arreglo, ", ");
// resultado = "100, 200, 300".
nf(entero, digitos)Da formato a un número entero según la cantidad de digitos especificada completando el número con ceros a la izquierda.
int i1 = 7;
int i2 = 30;
int i3 = 2008;
String s1 = nf(i1, 5);
// s1 = "00007".
String s2 = nf(i2, 3);
// s2 = "030".
String s3 = nf(i3, 6);
// s3 = "002008".
nfp(entero, digitos)Similar a nf() pero esta función agrega el símbolo mas (+) como prefijo de los valores positivos y el símbolo menos (–) como prefijo de los valores negativos.
int i1 = -7;
int i2 = 30;
int i3 = -2008;
String s1 = nfp(i1, 5);
// s1 = "-00007".
String s2 = nfp(i2, 3);
// s2 = "+030".
String s3 = nfp(i3, 6);
// s3 = "-002008".
nfs(entero, digitos)Es similar a nf() para dar formato a números enteros, sin embargo esta función agrega un espacio como prefijo a los valores positivos para que sus cifras se alineen correctamente con los valores negativos.
int i1 = -7;
int i2 = 30;
int i3 = -2008;
String s1 = nfp(i1, 5);
// s1 = "-00007".
String s2 = nfp(i2, 3);
// s2 = " 030".
String s3 = nfp(i3, 6);
// s3 = "-002008".
split(cadena, delimitador)Parte una cadena en subcadenas según las ocurrencias del delimitador y retorna un arreglo de las cadenas resultantes. Es funcionalmente opuesta a la función join().
String fecha = "31/03/2008";
String[] partes = split(fecha, '/');
// partes[0] = "31".
// partes[1] = "03".
// partes[2] = "2008".String numeros = "8 85 52 70";
int arreglo = int(split(numeros));
// arreglo[0] = 8.
// arreglo[1] = 85.
// arreglo[2] = 52.
// arreglo[3] = 70.
trim(cadena)Remueve los siguientes carácteres de ambos lados de la cadena: espacios en blanco, saltos de línea, tabulaciones y el carácter UNICODE “nbsp“.
String cadena = " Esta cadena tiene espacios de sobra ";
String corta = trim(cadena);
// corta = "Esta cadena tiene espacios de sobra".
La clase String por su parte incluye una gran variedad de métodos con los siguientes.
charAt(indice) | Este método retorna el iésimo elemento de la cadena. |
String saludo = "Hola Mundo";
char p1 = saludo.charAt(0);
// p1 = 'H'.
char p2 = saludo.charAt(3);
// p2 = 'a'.
char p3 = saludo.charAt(7);
// p3 = 'n'.
equals(cadena)Este método compara la cadena contra una segunda cadena recibida a través del parámetro y verifica si son la misma o no. Retorna true si las cadenas son la misma, false de lo contrario.indexOf(cadena, indice_inicio)Verifica si la cadena especificada es una subcadena de la propia y en caso de serlo retorna el índice de la ocurrencia, en caso de no serlo retorna siempre -1. El segundo parámetro: indice_inicio es opcional, en caso de especificarse la búsqueda se realiza a partir de dicho índice.
String cadena = "Esta es una cadena de ejemplo";
int p1 = cadena.indexOf("e");
// p1 = 5.
int p2 = cadena.indexOf("e", 6);
// p2 = 15.
int p3 = cadena.indexOf("no_esta");
// p3 = -1.
length()Este método retorna la longitud de la cadena.
String cadena = "Hola Mundo Loco";
int longitud = cadena.length();
// longitud = 15.
substring(indice_inicio, indice_final)Este método retorna una subcadena enmarcada en los índices especificados. El segundo índice: indice_final es opcional, en caso de no especificarse se considerará hasta el final de la cadena.
String cadena = "Esto es lo que somos";
String sub1 = cadena.substring(15);
// sub1 = "somos".
String sub2 = cadena.substring(8, 14);
// sub2 = "lo que".
toLowerCase()Este método retorna la cadena en letras minúsculas completamente.
String cadena = "Esta es una CADENA MuY vaRiaDa";
String lower = cadena.toLowerCase();
// lower = "esta es una cadena muy variada".
toUpperCase()Este método retorna la cadena en letras mayúsculas completamente.
String cadena = "Esta es una CADENA MuY vaRiaDa";
String upper = cadena.toUpperCase();
// upper = "ESTA ES UNA CADENA MUY VARIADA".
Para consultar la información de más métodos de la clase String refiérase a la documentación del API de Java.
Funciones relacionadas con arreglos.
append(arreglo, elemento) | Agrega el elemento al final del arreglo. El elemento debe ser de igual tipo que el arreglo |
String[] arreglo = {"uno", "dos", "tres"};
String[] nuevo = append(arreglo, "CUATRO");
// nuevo = {"uno", "dos", "tres", "CUATRO"}.
concat(arreglo1, arreglo2)Retorna la unión del arreglo1 con el arreglo2. Ambos arreglos deberán ser de igual tipo.
int[] arr1 = {1, 2, 3, 4};
int[] arr2 = {10, 20, 30, 40};
int[] resultado = concat(arr1, arr2);
// resultado = {1, 2, 3, 4, 10, 20, 30, 40}.
contract(arreglo, nuevo_tamaño)Retorna la versión contraída del arreglo referenciado. Los valores sobrantes son descartados.
int[] arreglo = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int longitud_completa = arreglo.length;
// longitud_completa = 10.
int[] resultado = contract(arreglo, 7);
int longitud_parcial = resultado.length;
// longitud_parcial = 7;
expand(arreglo, nuevo_tamaño)Esta función aumenta el tamaño del arreglo al nuevo_tamaño especificado. Si este segundo parámetro no se especifica se considerará el doble del tamaño actual.
int[] arreglo = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int longitud_completa = arreglo.length;
// longitud_completa = 10.
int[] resultado = expand(arreglo, 15);
int longitud_ampliada = resultado.length;
// longitud_ampliada = 15;
length(arreglo)Retorna la longitud o tamaño del arreglo. Esta función es análoga al atributo length.
String[] arreglo = {"primero", "segundo", "tercero", "cuarto"};
int longitud = length(arreglo);
// longitud = 4.
int tamano = arreglo.length;
// tamano = 4.
reverse(arreglo)Retorna una versión invertida: los elementos dispuestos en orden inverso, del arreglo original.
int[] arreglo = {1, 2, 3, 4, 5};
int[] inverso = reverse(arreglo);
// inverso = {5, 4, 3, 2, 1}.
shorten(arreglo)Retorna una copia del arreglo con su último elemento removido.
String[] arreglo = {"rojo", "azul", "verde", "cafe", "naranja"};
String[] corto = shorten(arreglo);
// corto = {"rojo", "azul", "verde", "cafe"}.
splice(arreglo, elemento, indice)Retorna una versión ampliada del arreglo con el elemento (puede ser un valor u otro arreglo) insertado en la posición indice.
int[] arreglo = {10, 20, 30, 40, 50};
arreglo = splice(arreglo, 15, 1);
// arreglo = {10, 15, 20, 30, 40, 50}.
int[] seccion = {32, 34, 36, 38};
arreglo = splice(arreglo, seccion, 4);
// arreglo = {10, 15, 20, 30, 32, 34, 36, 38, 40, 50}.
One Reply to “Tipos de datos de MobileProcessing”