Entrada y Salida de Datos

// Uso de Scanner para entrada estándar
Scanner lector = new Scanner(System.in);
int cantidad = lector.nextInt(); // Lee un entero
String linea = lector.nextLine(); // Lee una línea completa

// Optimización con BufferedReader
BufferedReader lectorRapido = new BufferedReader(new InputStreamReader(System.in));
String datos = lectorRapido.readLine();

StringBuilder para Manipulación de Cadenas

StringBuilder constructor = new StringBuilder();
constructor.setCharAt(0, 's'); // Modifica un carácter en posición específica

Conversiones de Tipo

// Convertir String a int (similar para otros tipos)
int valor = Integer.valueOf(cadena);
int num = Integer.parseInt(cadena);

Transformación de Listas a Arreglos

// Lista de arreglos a arreglo bidimensional
List<int> listaDatos = new ArrayList<>();
listaDatos.toArray(new int[listaDatos.size()][2]);

// Lista de enteros con inserción en posición específica
List<integer> elementos = new ArrayList<>();
elementos.add(0, 12);
elementos.add(0, 122);
</integer></int>

Operaciones con ArrayList

List<integer> resultado = new ArrayList<>();
resultado.clear(); // Elimina todos los elementos
Collections.reverse(resultado); // Invierte el orden de los elementos
</integer>

Valores Máximos y Mínimos

// Para Long, la lógica es similar
long maximo = Long.MAX_VALUE;
long minimo = Long.MIN_VALUE;

Manipulación de Cadenas

String texto = "ejemplo";
char[] caracteres = texto.toCharArray();
String subcadena = texto.substring(1, 4); // Extrae desde índice 1 hasta 3
int longitud = texto.length(); // Para arreglos, usar .length sin paréntesis
char c = texto.charAt(2); // Carácter en posición 2
String[] partes = texto.split("\\s+"); // Divide por espacios múltiples

String ruta = "//var////doc/fichero";
String[] segmentos = ruta.split("/+"); // Divide por barras consecutivas

Colecciones

HashMap

Map<string string=""> mapa = new HashMap<>();
mapa.put("clave", "valor");
String valorObtenido = mapa.getOrDefault("clave", "predeterminado"); // Obtiene valor o usa default
mapa.putIfAbsent("clave", "valor"); // Inserta solo si la clave no existe

// Recorrido recomendado
for (Map.Entry<string string=""> entrada : mapa.entrySet()) {
    System.out.println(entrada.getKey() + ": " + entrada.getValue());
}

// Uso de forEach con lambda
mapa.forEach((k, v) -> System.out.println(k + " : " + v));

// Iteración con clave
for (String clave : mapa.keySet()) {
    String valor = mapa.get(clave);
}
</string></string>

Colas y Pilas

// Cola con LinkedList
Queue<integer> cola = new LinkedList<>();
cola.peek(); // Consulta el frente sin remover
cola.poll(); // Remueve y retorna el frente, retorna null si vacía
int tamano = cola.size();

// Cola de prioridad
PriorityQueue<integer> colaPrioridad = new PriorityQueue<>();
Iterator<integer> iterador = colaPrioridad.iterator();
while (iterador.hasNext()) {
    System.out.println(iterador.next());
}

// Pila usando Deque
Deque<integer> pila = new LinkedList<>();
pila.push(elemento);
pila.pop();
pila.peek();
int elementosPila = pila.size();
</integer></integer></integer></integer>

Ordenamiento Personalizado

// Ejemplo: ordenar arreglo bidimensional por primera columna ascendente, segunda descendente
Arrays.sort(arreglo, new Comparator<int>() {
    public int compare(int[] a, int[] b) {
        if (a[0] == b[0]) {
            return b[1] - a[1];
        }
        return a[0] - b[0];
    }
});

// Alternativa con expresión lambda
Arrays.sort(arreglo, (a, b) -> {
    if (a[0] == b[0]) {
        return a[1] - b[1];
    }
    return a[0] - b[0];
});
</int>

Formato de Salida

// Formatear número con 6 decimales
double porcentaje = ((suma - 1) / total) * 100;
System.out.println(String.format("%.6f", porcentaje));

Números de Catalan

Aplicaciones: cálculo de salidas válidas en pilas y árboles binarios de búsqueda.

Suma de Cadenas Binarias

// Convertir decimal a binario y sumar
public String sumarBinarios(String a, String b) {
    int valorA = Integer.valueOf(a, 2);
    int valorB = Integer.valueOf(b, 2);
    int suma = valorA + valorB;
    return Integer.toBinaryString(suma);
}

Operaciones de Redondeo

En Java, m/n realiza división entera (redondeo hacia abajo). Para redondeo hacia arriba, usar (m + n - 1) / n.

Relleno de Arreglos

// Rellenar arreglo con un valor específico
Arrays.fill(arregloNumeros, 5);

Máximo Común Divisor (GCD)

public static int calcularGCD(int a, int b) {
    return b == 0 ? a : calcularGCD(b, a % b);
}

Suma con Java Stream

int sumaTotal = Arrays.stream(arreglo).sum();

Construcción de Colas de Prioridad

// Cola mínima y máxima
PriorityQueue<integer> colaMin = new PriorityQueue<>(Comparator.naturalOrder());
PriorityQueue<integer> colaMax = new PriorityQueue<>(Comparator.reverseOrder());

// Cola ordenada por segundo elemento de un arreglo
PriorityQueue<int> colaPersonalizada = new PriorityQueue<>((a, b) -> a[1] - b[1]);
</int></integer></integer>

Generación de Números Aleatorios

// Número aleatorio entre 0 (inclusivo) y n (exclusivo)
int aleatorio = new Random().nextInt(n);

Conversión de Lista a Arreglo

List<int> lista = new ArrayList<>();
int[][] arregloResultado = lista.toArray(new int[lista.size()][2]);
</int>