Yo solucionaría el error devolviendo el nuevo balance en los métodos `deposit()` y `withdraw()`, y reasignando el valor de la variable `balance`: ```java import java.util.ArrayList; public class example { public static void main(String[] args) { double balance = 1000.0; ArrayList<String> transactionHistory = new ArrayList<>(); balance = deposit(500, balance, transactionHistory); balance = withdraw(100, balance, transactionHistory); System.out.println("Balance final: " + balance); for (String transaction : transactionHistory) { System.out.println(transaction); } } public static double deposit(double amount, double balance, ArrayList<String> transactionHistory) { balance += amount; transactionHistory.add("Deposited: $" + amount); return balance; } public static double withdraw(double amount, double balance, ArrayList<String> transactionHistory) { if (balance >= amount) { balance -= amount; transactionHistory.add("Withdrew: $" + amount); } else { System.out.println("Insufficient funds"); } return balance; } } ```

El hashmap seria util en un sistema ATM, para asociar a los numeros de cuenta con su respectivo balances.

* **Paso por valor**: Se crea una copia local de la variable dentro de la función. * **Paso por referencia**: Se maneja directamente la variable, los cambios realizados dentro de la función le afectarán también fuera.

el peor cuso por ahora

Un `HashMap` en Java almacena pares clave-valor, permitiendo una búsqueda rápida. Aquí un ejemplo comentado: ```java import java.util.HashMap; public class Main { public static void main(String[] args) { // Crear un HashMap para almacenar balances de cuentas HashMap<String, Double> balances = new HashMap<>(); // Agregar balances balances.put("cuenta1", 1500.00); // Clave 'cuenta1' con valor 1500.00 balances.put("cuenta2", 2500.50); // Clave 'cuenta2' con valor 2500.50 // Obtener el balance de 'cuenta1' Double balanceCuenta1 = balances.get("cuenta1"); System.out.println("Balance de cuenta1: " + balanceCuenta1); // Eliminar 'cuenta2' balances.remove("cuenta2"); // Verificar si 'cuenta2' existe System.out.println("¿cuenta2 existe? " + balances.containsKey("cuenta2")); } } ``` Este código muestra cómo utilizar un `HashMap` para gestionar balances de cuentas de forma eficiente.

esta clase me acuerda Data Structures & Algorithms en la Universidad :)

Crear un HashMap, que vincule una transacción con un monto

Para iterar sobre un Array y un ArrayList en Java, puedes usar un bucle `for` y un bucle `for-each` respectivamente. Aquí tienes ejemplos comentados: ```java // Ejemplo de iteración sobre un Array int[] transactionIds = {101, 102, 103, 104, 105}; // Declaración e inicialización del Array for (int i = 0; i < transactionIds.length; i++) { // Bucle for para recorrer el Array System.out.println(transactionIds[i]); // Imprime cada identificador de transacción } // Ejemplo de iteración sobre un ArrayList ArrayList<String> transactionHistory = new ArrayList<>(); // Crear un ArrayList transactionHistory.add("Depósito de 500 dólares"); // Añadir transacción transactionHistory.add("Retiro de 200 dólares"); // Añadir otra transacción for (String transaction : transactionHistory) { // Bucle for-each para recorrer el ArrayList System.out.println(transaction); // Imprime cada transacción en el historial } ``` Estos ejemplos muestran cómo acceder a los elementos de cada estructura de datos.

```java import java.util.ArrayList; public class Main { public static void main(String[] args) { ArrayList<String> transactionHistory = new ArrayList<>(); // Agregar elementos transactionHistory.add("Depósito de 500 dólares"); transactionHistory.add("Retiro de 200 dólares"); // Obtener un elemento String firstTransaction = transactionHistory.get(0); System.out.println("Primera transacción: " + firstTransaction); // Modificar un elemento transactionHistory.set(0, "Depósito de 1000 dólares"); // Eliminar un elemento transactionHistory.remove(1); // Imprimir el historial for (String transaction : transactionHistory) { System.out.println(transaction); } } } ``` Este código muestra cómo utilizar `ArrayList` para agregar (`add`), obtener (`get`), modificar (`set`) y eliminar (`remove`) elementos. Puedes adaptar estos conceptos en tu proyecto Java.

Les compartos unos \[apuntes en Notion]\(https://cabosmanuel.notion.site/Collections-ac2450eeba4d4ec4b6a88ca86792dea2?pvs=4) que tengo con más detalles sobre las **Colecciones** en Java, incluyendo HashMap, ArrayList, LinkedList, ventajas/desventajas, casos de uso y gráficos, Clases e Interfaces, sus herencias e implementación:  

yo pude hacer que se pueda compartir el monto de la propiedad entre los metodos no se si es buena practica *public* *class* Main { *public* *static* double balance = 0; *public* *static* void *main*(String\[] arg) { System.*out*.*println*("hello word"); *deposit*(300.30); *withdrew*(200); *deposit*(300.30); *withdrew*(1000); *deposit*(400.00); } *public* *static* void *deposit*(double mount) { balance += mount; System.*out*.*println*("new balance: " + balance); }; *public* *static* void *withdrew*(int mount) { *if* (mount < balance) { balance -= mount; System.*out*.*println*("new balance: " + balance); } *else* { System.*out*.*println*("Don't have mounts enough"); } }}

✅

Honestamente, este nuevo formata me abruma demasiado. No es que no le pueda seguir la pista al maestro, pero es que se siente que solo va pasando de un tema a otra y uno no tiene como idea de como va todo. Creo que mejor vere los viejos cursos. :/ Es una lastima, porque justo necesito aprender java para mi trabajo y pense que este curso seria mi salvacion.

Creo que el tema de LinkedList está de más, se aborda demásiado rápido, sin ejemplo, solo se menciona una de las caracteristicas, tal vez deberían quitarlo o complementarlo.

El uso de BigDecimal para manejar montos monetarios es una buena práctica? Por lo que sé float y double tienen problemas de redondeo.

Sí, se puede hacer un array de arrays en Java, conocido como "array multidimensional". Se declara utilizando corchetes adicionales. Por ejemplo: ```java int[][] matrix = new int[3][3]; // Un array de 3x3 ``` Esto es útil para representar estructuras como tablas o matrices.

Un HashMap sería útil en un sistema ATM para ubicar u ordenar de manera rápida los balances de cuenta por fecha, además del balance actual en tiempo real asociado al número de cuenta.

Para mi solución, agregue una función transaction ```java package org.example; import java.util.ArrayList; public class Main { public static double transaction(double amount, double balance, ArrayList<String> history, int type) { if (type == 1) { balance += amount; history.add("Deposito: $" + amount); } if (type == 0) { if (balance > amount) { balance -= amount; history.add("Retiro: $" + amount); } else { System.out.println("Fondos insuficientes!! :("); } } return balance; } public static void main(String[] args) { double balance = 1000.00; ArrayList<String> transactionsHistory = new ArrayList<>(); balance = transaction(250.34, balance, transactionsHistory, 1); balance = transaction(500.40, balance, transactionsHistory, 0); System.out.println("<---- Historial de transacciones ---->"); for (String tr: transactionsHistory) { System.out.println(tr); } System.out.println("<-------------------------------->"); System.out.println("Balance de cuenta: $" + balance); } } ```package org.example; import java.util.ArrayList; public class Main { public static double transaction(double amount, double balance, ArrayList\<String> history, int type) { if (type == 1) { balance += amount; history.add("Deposito: $" + amount); } if (type == 0) { if (balance > amount) { balance -= amount; history.add("Retiro: $" + amount); } else { System.*out*.println("Fondos insuficientes!! :("); } } return balance; } public static void main(String\[] args) { double balance = 1000.00; ArrayList\<String> transactionsHistory = new ArrayList<>(); balance = *transaction*(250.34, balance, transactionsHistory, 1); balance = *transaction*(500.40, balance, transactionsHistory, 0); System.*out*.println("<---- Historial de transacciones ---->"); for (String tr: transactionsHistory) { System.*out*.println(tr); } System.*out*.println("<-------------------------------->"); System.*out*.println("Balance de cuenta: $" + balance); } }

Un **HashMap** para cada transacción de esta forma se puede buscar rápidamente una transacción

import java.util.ArrayList; public class Main { public static void main(String\[] args) { double balance = 1000.0; ArrayList\<String> transactionHistory = new ArrayList<>(); balance = deposit(500, balance, transactionHistory); balance = withdraw(100, balance, transactionHistory); System.out.println("Balance final: " + balance); for (String transaction : transactionHistory) { System.out.println(transaction); } } public static double deposit(double amount, double balance, ArrayList\<String> transactionHistory) { balance += amount; transactionHistory.add("Deposited: $" + amount); return balance; } public static double withdraw(double amount, double balance, ArrayList\<String> transactionHistory) { if (balance >= amount) { balance -= amount; transactionHistory.add("Withdrew: $" + amount); } else { System.out.println("Insufficient funds"); } return balance; } }