Tipos de datos de MobileProcessing

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}.