Java (chuleta)

public class MiPrimeraAplicacion {
  public static void main (String[] args) {
    System.out.println("Hola Mundo");
  }
}

Tipos de datos

boolean Puede contener los valores true o false.
byte Enteros. Tamaño 8-bits. Valores entre -128 y 127.
short Enteros. Tamaño 16-bits. Entre -32768 y 32767.
int Enteros. Tamaño 32-bits. Entre -2147483648 y 2147483647.
long Enteros. Tamaño 64-bits. Entre -9223372036854775808 y 9223372036854775807.
float Números en coma flotante. Tamaño 32-bits.
double Números en coma flotante. Tamaño 64-bits.
char Caracteres. Tamaño 16-bits. Unicode. Desde ‘u0000’ a ‘uffff’ inclusive. Esto es desde 0 a 65535

System.out.printf("Hello %s!%n", "World");

1	`Hello World!`

s Formats strings
S String en mayuscula
d Formats decimal integers
f Formats the floating-point numbers
t Formats date/time values
n Salto linea
b Boolean
c Char unicode

1	`%[flags][width][.precision]conversion-character`

The [flags] define standard ways to modify the output and are most common for formatting integers and floating point numbers.

The [width] specifies the field width for outputting the argument. It represents the minimum number of characters written to the output.

The [.precision] specifies the number of digits of precision when outputting floating-point values. Additionally, we can use it to define the length of a substring to extract from a String.

12	`System.out.printf(Locale.US,` `"%,d %n",` `10000);System.out.printf(Locale.ITALY,` `"%,d %n",` `10000);`

12	`10,000` `10.000`

1	`System.out.printf("%f%n",` `5.1473);`

1	`5.147300`

1	`System.out.printf("'%5.2f'%n",` `5.1473);`

1 ' 5.15'

1	`System.out.printf("'%5.2e'%n",` `5.1473);`

1	`'5.15e+00'`

‘H’, ‘M’, ‘S’ – characters are responsible for extracting the hours, minutes and second from the input Date
‘L’, ‘N’ – to represent the time in milliseconds and nanoseconds accordingly
‘p’ – adds am/pm formatting
‘z’ – prints out the timezone offset

12	`Date date =` `new` `Date();System.out.printf("%tT%n", date);`

1	`13:51:15`

1	`System.out.printf("hours %tH: minutes %tM: seconds %tS%n", date, date, date);`

1	`hours 13: minutes 51: seconds 15`

1	`System.out.printf("%1$tH:%1$tM:%1$tS %1$tp %1$tL %1$tN %1$tz %n", date);`

1	`13:51:15 pm 061 061000000 +0400`

‘A’ – prints out the full day of the week
‘d’ – formats a two-digit day of the month
‘B’ – is for the full month name
‘m’ – formats a two-digit month
‘Y’ – outputs a year in four digits
‘y’ – outputs the last two digits of the year

1	`System.out.printf("%1$tA, %1$tB %1$tY %n", date);`

1	`Thursday, November 2018`

1	`System.out.printf("%1$td.%1$tm.%1$ty %n", date);`

Sentencias

int valor = 2;
valor = 2;
valor++;
System.out.println("Hola Mundo");
Circulo miCirculo = new Circulo(2,3);
if (valor>1) { … }
if (expresion) {
    // Bloque 1
} else {
    // Bloque 2
}

Manejo de Cadenas

.length() Nos devuelve el tamaño que tiene la cadena.

char charAt(int index) Devuelve el carácter indicado como índice. Si intentamos acceder a un índice de carácter que no existe nos devolverá una excepción IndexOutOfBoundsException.

boolean equals(Object anObject) Nos permite comparar si dos cadenas de texto son iguales. Si queremos omitir la validación de mayusculas/minusculasesta validación tenemos dos opciones. La primera es convertir las cadenas a mayúsculas o minúsculas con los métodos .toUpperCase() y .toLowerCase() respectivamente. O puedes es utilizar el método .equalsIgnoreCase().

boolean equalsIgnoreCase(String anotherString) Compara dos cadenas de caracteres omitiendo si los caracteres están en mayúsculas o en minúsculas.

int compareTo(String anotherString) Compara a las cadenas léxicamente. Para ello se basa en el valor Unicode de los caracteres. Se devuelve un entero menor de 0 si la cadena sobre la que se parte es léxicamente menor que la cadena pasada como argumento. Si las dos cadenas son iguales léxicamente se devuelve un 0.

s1 = "Cuervo"
s2 = "Cuenca"
s1.compareTo(s2);

int compareToIgnoreCase(String str) Este método se comportará igual que el anterior. Pero ignorando las mayúsculas.

Búsqueda de caracteres

int indexOf(int ch) Nos devuelve la posición de un carácter dentro de la cadena de texto. En el caso de que el carácter buscado no exista nos devolverá un -1.

int indexOf(int ch, int fromIndex) Lo mismo pero desde el índice (fromIndex) que le indiquemos.

int lastIndexOf(int ch) Nos indica cual es la última posición que ocupa un carácter dentro de una cadena. Si el carácter no está en la cadena devuelve un -1.

int lastIndexOf(int ch, int fromIndex) Lo mismo que el anterior, pero a partir de una posición indicada como argumento.

int indexOf(String str) Busca una cadena dentro de la cadena origen. Devuelve un entero con el índice a partir del cual está la cadena localizada. Si no encuentra la cadena devuelve un -1.

int indexOf(String str, int fromIndex) Misma funcionalidad que indexOf(String str), pero a partir de un índice indicado como argumento del método.

int lastIndexOf(String str) Si la cadena que buscamos se repite varias veces en la cadena origen podemos utilizar este método que nos indicará el índice donde empieza la última repetición de la cadena buscada.

lastIndexOf(String str, int fromIndex) Lo mismo que el anterior, pero a partir de un índice pasado como argumento.

boolean startsWith(String prefix) Probablemente mucha gente se haya encontrado con este problema. El de saber si una cadena de texto empieza con un texto específico. La verdad es que este método podía obviarse y utilizarse el indexOf(), con el cual, en el caso de que nos devolviese un 0, sabríamos que es el inicio de la cadena.

boolean startsWith(String prefix, int toffset) Más elaborado que el anterior, y quizás, y a mi entender con un poco menos de significado que el anterior.

boolean endsWith(String suffix) Y si alguien se ha visto con la necesidad de saber si una cadena empieza por un determinado texto, no va a ser menos el que se haya preguntado si la cadena de texto acaba con otra. De igual manera que sucedía con el método .startsWith() podríamos utilizar una mezcla entre los métodos .indexOf() y .length() para reproducir el comportamiento de .endsWith(). Pero las cosas, cuanto más sencillas, doblemente mejores.

Métodos con subcadenas

String substring(int beginIndex) Este método nos devolverá la cadena que se encuentra entre el índice pasado como argumento (beginIndex) hasta el final de la cadena origen.

String substring(int beginIndex, int endIndex) Si se da el caso que la cadena que queramos recuperar no llega hasta el final de la cadena origen, que será lo normal, podemos utilizar este método indicando el índice inicial y final del cual queremos obtener la cadena.

Manejo de caracteres

String toLowerCase(); Convierte todos los caracteres en minúsculas.

String toUpperCase(); Convierte todos los caracteres a mayúsculas.

String trim(); Elimina los espacios en blanco de la cadena.

String replace(char oldChar, char newChar) Este método lo utilizaremos cuando lo que queramos hacer sea el remplazar un carácter por otro. Se reemplazarán todos los caracteres encontrados.

Conversión a String: valueOf()

Arrays

tipo_dato nombre_array[];
nombre_array = new tipo_dato[tamanio];

char arrayCaracteres[];
arrayCaracteres = new char[10];

char array[];
array = new char[10];

for (int x=0;x<array.length;x++)
  System.out.printnln(array[x]);

Matrices o Arrays de varios subindices

tipo_dato nombre_array[][];
nombre_array = new tipo_dato[tamanio][tamanio];

int matriz[][];
matriz = new int[2][2];

int x = matriz[1][1]; // Para leer el contenido de un elemento
matriz[1][1] = x;     // Para asignar un valor.

int matriz[][];
matriz = new int[4][4];
for (int x=0; x < matrix.length; x++) {
  for (int y=0; y < matriz[x].length; y++) {
      System.out.println (matriz[x][y]);
  }
}

Incialización de Arrays en Java

tipo_dato array[] = {elemento1,elemento2,...,elementoN};

// Tenemos un array de 5 elementos.
char array[] = {'a','b','c','d','e'};

// Tenemos un array de 4x4 elementos.
int array[][] = { {1,2,3,4}, {5,6,7,8}};

Listas

Una Lista es una construcción de colección que, por definición, es una colección ordenada, también conocida como una secuencia.

Una colección de Lista Java solo puede tener objetos y define un contrato estricto sobre cómo se comporta.

La Lista es una interfaz, por lo que usted no puede crear una instancia de ella directamente. Trabajará con su implementación más comúnmente usada, ArrayList:

1	`List<Object> listOfObjects = new ArrayList<Object>();`

Tipo formal

¿Qué sucede con el <Object> en el recorte anterior del código? Se llama el tipo formal y le comunica al compilador que esta Lista contiene una colección de tipo Object, lo que significa que puede poner prácticamente lo que quiera en la Lista.

Si usted quisiera intensificar las restricciones sobre lo que pudiera o no ir en la Lista, la definiría de modo diferente:

1	`List<Person> listOfPersons = new ArrayList<Person>();`

Ahora su Lista solo puede tener instancias de Person.

Uso de las `Lista`s

add()

List<Integer> listOfIntegers = new ArrayList<Integer>();
listOfIntegers.add(Integer.valueOf(238));

size()

List<Integer> listOfIntegers = new ArrayList<Integer>();
listOfIntegers.add(Integer.valueOf(238));
Logger l = Logger.getLogger("Test");
l.info("Current List size: " + listOfIntegers.size());

get()

List<Integer> listOfIntegers = new ArrayList<Integer>();
listOfIntegers.add(Integer.valueOf(238));
Logger l = Logger.getLogger("Test");
l.info("Item at index 0 is: " listOfIntegers.get(0))

`Iterable`

Si una colección implementa java.lang.Iterable, se llama una colección iterable. Eso significa que usted puede comenzar por un extremo y recorrer la colección elemento por elemento hasta que se le acaben los elementos.

for (objectType varName : collectionReference) {  
   // Start using     
   objectType (via varName) right away...
}

Iteración en una `Lista`

List<Integer> listOfIntegers = obtainSomehow();
Logger l = Logger.getLogger("Test");
for (Integer i : listOfIntegers) {
    l.info("Integer value is : " + i);
}

Conjuntos

Un Conjunto es una construcción de colecciones que por definición contiene elementos únicos, — es decir, ningún duplicado. Mientras que una Lista puede contener el mismo objeto cientos de veces, un Conjunto solo puede contener cierta instancia una vez. Una colección de Conjunto Java solo puede tener objetos y define un contrato estricto sobre cómo se comporta.

Set<Integer> setOfIntegers = new HashSet<Integer>();
setOfIntegers.add(Integer.valueOf(10));
setOfIntegers.add(Integer.valueOf(11));
setOfIntegers.add(Integer.valueOf(10));
for (Integer i : setOfIntegers) {
    l.info("Integer value is: " + i);
}

Puede que usted espere que el Conjunto tenga tres elementos en él pero de hecho solo tiene dos porque el objeto Integer que contiene el valor 10 solo se agregará una vez.

Es posible que los objetos se impriman en un orden diferente del que usted los agregó porque un Conjunto garantiza la singularidad, no el orden. Verá esto por usted mismo si pega el código anterior en el método main() de su clase Person y lo ejecuta.

Mapas

Un Mapa es una construcción de colección útil porque le permite asociar un objeto (la clave) con otro (el valor). Como puede imaginar, la clave para el Mapa debe ser única y se usa para recuperar el valor en un momento posterior. Una colección de Mapa Java solo puede tener objetos y define un contrato estricto sobre cómo se comporta.

Uso de los `Mapa`s

Para poner algo en un Mapa, necesita tener un objeto que represente su clave y un objeto que represente su valor:

public Map<String, Integer> createMapOfIntegers() {
    Map<String, Integer> mapOfIntegers = new HashMap<String, Integer>();
    mapOfIntegers.put("1", Integer.valueOf(1));
    mapOfIntegers.put("2", Integer.valueOf(2));
    mapOfIntegers.put("3", Integer.valueOf(3));
    // . . .
    mapOfIntegers.put("168", Integer.valueOf(168));
}

Es este ejemplo, el Mapa contiene Integers, con la clave hecha por una String, que resulta ser su representación de String. Para recuperar un valor Integer particular, necesita su representación String:

12	`mapOfIntegers = createMapOfIntegers();` `Integer oneHundred68 = mapOfIntegers.get("168");`

Uso del `Conjunto` con el `Mapa`

En ocasiones, usted puede encontrarse con una referencia a un Mapa y simplemente quiere recorrer todo el conjunto de contenidos. En este caso, necesitará un Conjunto de las claves para el Mapa:

Set<String> keys = mapOfIntegers.keySet();
Logger l = Logger.getLogger("Test");
for (String key : keys) {
    Integer value = mapOfIntegers.get(key);
    l.info("Value keyed by '" + key + "' is '" + value + "'");
}

Observe que el método toString() del Integer recuperado desde el Mapa se llama automáticamente cuando se usa en la llamada del Logger. El Mapa no devuelve una Lista de sus claves porque se hace una clave para el Mapa y cada clave es única; la singularidad es la característica distintiva de un Conjunto.