Cheat Sheet JAVA 🥷

Cheat Sheet JAVA 🥷


Cheat Sheet
java basico referencia repaso

Tabla de Contenido


Cositas usadas en Java

Estructuras de Control

IF / ELSE
if (a > b) {
    System.out.println(a);
} else {
    System.out.println(b);
}
IF / ELSE: ¿está x en el rango de low a high?
if (low <= x && x <= high) {
    System.out.println("en rango");
} else {
   System.out.println("fuera de rango");
}
SWITCH / CASE
switch (n) {
    case 1:
        System.out.println("uno");
        break;
    case 2:
        System.out.println("dos");
        break;
    default:
        System.out.println("algo más");
        break;
} // fin del switch (n)

Bucles

FOR: utilizado cuando se conoce el número máximo de iteraciones de antemano
for (int i = 0; i < n; i++) {
    System.out.println(i);
}
FOR: para recorrer cada carácter de una cadena, de izquierda a derecha
for (int i = 0, n = s.length(); i < n; i++) {
    System.out.println(s.charAt(i));
}
REVERSE FOR: para contar hacia atrás
for (int i = n - 1; i >= 0; i--) {
    System.out.println(i);
}
REVERSE FOR: para recorrer cada carácter de una cadena, de derecha a izquierda
for (int i = s.length() - 1; i >= 0; i--) {
    System.out.println(s.charAt(i));
}
DUAL FOR
for (int i = 0, j = 0; i < n; i++, j++) {
    System.out.println(i);
}
// Sin embargo, esto es ilegal!
// for (int i = 0, float r = 1.0; i < n; i++, r = r*2.0) {
//    out.println(i);
// }
FOR: Recorriendo un arreglo
String[] stuff = new String[10];
for (int i = 0; i < n; i++) {
    String s = stuff[i];
    System.out.println(s);
}
FOR EACH: Recorriendo un arreglo con for-each
String[] stuff = new String[10];
for (String s : stuff) {
    System.out.println(s);
    s = "algo diferente"; // ¡Cuidado! Esto no afecta al arreglo stuff[].
}
FOR EACH: Recorriendo un enum con for-each
enum Breed { DALMATIAN, LABRADOR, DACHSHUND }
for (Breed dog : Breed.values()) {
    System.out.println(dog);
}
WHILE: bucle que itera hasta 10
while (n <= 10) {
            System.out.println(n);
            n++; // Incremento en 1
        }
DO/WHILE: bucle que se ejecuta al menos una vez
do {
    readIt();
 
    if (done()) {
        break;
    }
 
    if (bypassThisOne()) {
        continue;
    }
 
    processIt();
} while (moreData());

Estructuras de control de errores

Permiten manejar correctamente los errores, permitiendo una ejecución del programa más segura y predecible.

  • try: Un bloque que intenta ejecutar código que podría lanzar una excepción.
  • catch: Un bloque que maneja la excepción. Puedes capturar uno o varios tipos de excepciones en el mismo bloque catch utilizando el símbolo de barra vertical (|) para separar los tipos de excepciones en Java 7 y versiones posteriores.
  • throw: Utilizado para lanzar una excepción. Puedes lanzar cualquier objeto que sea una instancia de la clase Throwable (o una de sus subclases).
Try/Catch/Throw
public class Test extends StandardTest {
    public static void main(String[] args) {
        try {
            dangerMethod();
        } catch (StrangeException e) {
            System.out.println("oops" + e.getMessage());
        }
    } // fin del main
 
    void dangerMethod() throws StrangeException {
        if (unexpected()) throw new StrangeException("oh oh");
    } // fin de dangerMethod
} // fin de la clase Test
Ejemplo de implementación
public class TryCatch {
    // Definición de la excepción personalizada StrangeException
    static class StrangeException extends Exception {
        public StrangeException(String message) {
            super(message);
        }
    }
 
    // Simular condición que podría lanzar una excepción
    static boolean unexpected() {
        return true; // Simplemente devuelve true para este ejemplo
    }
 
    // Método que podría lanzar una StrangeException
    static void dangerMethod() throws StrangeException {
        if (unexpected()) throw new StrangeException("oh oh");
    }
 
    public static void main(String[] args) {
        try {
            dangerMethod();
        } catch (StrangeException e) {
            System.out.println("oops: " + e.getMessage()); // Imprime el mensaje de la excepción
        }
    }
}

Literales

TipoEjemplos y Notas
int1, -1, 0x0f28 (hex), ‘\u003f’ (Unicode hex), 027 (octal), 2_147_483_647 (Integer.MAX_VALUE), -2_147_483_648 (Integer.MIN_VALUE). Cuidado con el 0 inicial para octales.
byte/shortNo existen literales específicos. Se deben usar con casteo, por ejemplo, (byte)0xff, (short)-99.
long3L, -99l, 0xf011223344L, 9_223_372_036_854_775_807L (Long.MAX_VALUE), -9_223_372_036_854_775_808L (Long.MIN_VALUE). Cuidado con los literales sin una ‘L’ al final.
float1.0345F, 1.04E-12f, .0345f, Float.NaN. Sin el f o F al final se consideran double.
double5.6E-120D, 123.4d, 0.1, Double.NaN, Math.PI. Los literales flotantes sin f, F, d, o D son considerados double.
booleantrue y false.
String”abcdefghijklmnopqrst” + “uvwxyz”; La concatenación con + se realiza en tiempo de compilación sin penalización de velocidad. Los literales String pueden usarse en cualquier lugar donde se usaría una referencia a String.
char’A’, (char)45, ‘\u003f’. Para caracteres problemáticos, ver secuencias de escape abajo.
Secuencias de EscapeIncluyen: ‘\n’ (nueva línea), ‘\t’ (tabulación), ’\\’ (barra invertida), ’\” (comilla simple), ’\”’ (comilla doble), ‘\u003f’ (Unicode hex), ‘\377’ (octal).

Notas adicionales:

  • Los literales int con un 0 inicial se interpretan como octales, lo cual puede introducir errores confusos.
  • Para byte y short no existen literales específicos; se requiere casteo.
  • En float y double, el punto decimal es opcional al inicio (p.ej., .1d), pero algunos compiladores pueden requerirlo.
  • Java no soporta literales de String de 32 bits como en C (e.g., \U0001d504). Para caracteres Unicode de más de 16 bits se deben usar pares sustitutos.

Primitivos vs Clases envoltorio inmutables

En la tabla siguiente se destaca cómo cada tipo primitivo tiene una clase envoltorio asociada en Java, la cual permite a los tipos primitivos ser tratados como objetos, ofreciendo métodos útiles para operaciones comunes y la posibilidad de ser utilizados en colecciones genéricas, donde se requieren objetos en lugar de tipos primitivos.

Tipos PrimitivosObjetos Inmutables (Wrapper Classes)
booleanBoolean
shortShort
charCharacter
intInteger
longLong
floatFloat
doubleDouble
char[]String

Notas clave sobre primitivos y sus objetos envoltorio:

  • Tipos Primitivos: Son la base de los datos en Java y se almacenan de manera eficiente en la memoria. No tienen métodos asociados ya que no son objetos.

  • Objetos Inmutables (Wrapper Classes): Permiten a los tipos primitivos ser tratados como objetos. Esto es especialmente útil en colecciones, tales como ArrayList, donde los tipos deben ser objetos. Además, proporcionan métodos útiles para convertir entre tipos, comparar, y más.

  • Inmutabilidad: Las clases envoltorio son inmutables, lo que significa que una vez que se crea una instancia de uno de estos objetos, su valor no puede cambiar. Si necesitas modificar el valor, debes crear una nueva instancia.

  • Uso de char[] y String: Mientras que char[] es un arreglo de caracteres primitivos y no tiene una clase envoltorio directa, String representa una secuencia de caracteres y es inmutable. Aunque no es un envoltorio en el sentido tradicional, String facilita trabajar con secuencias de caracteres como objetos.


Operadores

PrecedenciaOperadoresAsociaciónNotas
0newDerechanew no se considera oficialmente un operador según la Especificación del Lenguaje Java (JLS). Se utiliza exclusivamente seguido por un nombre de clase.
1++ (prefijo), -- (prefijo), + (unario), - (unario), ~, !, (tipo)DerechaOperadores unarios y de incremento/decremento. El ++ prefijo y -- prefijo cambian el valor antes de usarlo en la expresión. ! es el NOT lógico. (tipo) se utiliza para el casting.
1++ (postfijo), -- (postfijo)DerechaEl ++ postfijo y -- postfijo cambian el valor justo después de su uso en la expresión.
2*, /, %IzquierdaMultiplicación, división y módulo.
3+, -IzquierdaSuma, resta y concatenación de cadenas.
4<<, >>, >>>IzquierdaDesplazamientos bit a bit.
5<, <=, >, >=, instanceofIzquierdaComparaciones y comprobación de tipo.
6==, !=IzquierdaIgualdad y desigualdad.
7&IzquierdaAND a nivel de bits.
8^IzquierdaXOR a nivel de bits.
9|IzquierdaOR a nivel de bits.
10&&IzquierdaAND lógico cortocircuitado.
11||IzquierdaOR lógico cortocircuitado.
12? :DerechaOperador ternario (condicional).
13=, *=, /=, +=, -=, <<=, >>=, >>>=, &=, ^=, |=DerechaAsignación y asignación compuesta.

Referencia: