1.
Fundamentos Conceptuales (El “Qué” y el “Por qué”)
¿Qué es un arreglo en Processing y en qué se diferencia de una variable común?
Un arreglo (array) es una estructura de datos que almacena múltiples valores del mismo tipo
bajo un solo nombre de variable. Cada valor se accede mediante un índice (posición).
Una variable común (como `int x = 5;`) solo guarda un valor. Un arreglo permite guardar
muchos valores relacionados de forma organizada.
¿Por qué son fundamentales los arreglos cuando queremos crear gráficos masivos (por
ejemplo, animar 100 partículas en lugar de solo una)?
Permiten manejar eficientemente grandes cantidades de objetos similares (partículas,
estrellas, enemigos, etc.). En vez de crear 100 variables (`particle1`, `particle2`…), usas un
arreglo y un ciclo para actualizar y dibujar todas con pocas líneas de código. Esto hace el
código más limpio, escalable y fácil de mantener.
¿Cuáles son las restricciones de un arreglo?
Tamaño fijo: Una vez creado, su longitud no cambia (aunque Processing ofrece funciones
como `expand()` o `append()` que crean un nuevo arreglo más grande).
Homogeneidad de tipos: Todos los elementos deben ser del mismo tipo (todos `int`, todos
`float`, todos `PVector`, etc.). No puedes mezclar tipos diferentes.
2. Sintaxis y Creación (El “Cómo”)
¿Cuáles son los tres pasos obligatorios para usar un arreglo?
1. Declaración: Indicas el tipo y el nombre.
2. Creación / asignación de tamaño: Usas `new` para reservar espacio en memoria.
3. Inicialización: Asignas valores a cada posición (puede hacerse al momento de creación).
¿Cómo se escribe la sintaxis para declarar un arreglo de números enteros (int) y uno de
decimales (float)?**
```processing
Int[] numeros; // Declaración
Float[] coordenadas; // Declaración
Numeros = new int[100]; // Creación con tamaño 100
Coordenadas = new float[50];
```
También se puede en una sola línea o con inicialización directa:
```processing
Int[] numeros = {10, 20, 30};
Float[] valores = new float[10];
```
¿Qué es el índice de un arreglo y por qué el primer elemento siempre está en la posición 0 y
no en la 1?
El índice es el número de posición de cada elemento. Empieza en 0 (zero-based indexing),
una convención estándar en casi todos los lenguajes de programación (C, Java, JavaScript,
etc.). El último elemento está en `[Link] – 1`.
¿Cómo se utiliza la propiedad .length para conocer el tamaño de un arreglo
dinámicamente?
```processing
Int tam = [Link]; // Devuelve el número de elementos
```
Es muy útil en ciclos para no hardcodear el tamaño.
3. Manipulación y Ciclos (La práctica real)
¿Cómo se utiliza un ciclo for para recorrer un arreglo?
```processing
For (int i = 0; i < [Link]; i++) {
miArreglo[i] = i * 10; // Llenar
println(miArreglo[i]); // Leer
}
```
¿Qué es el error ArrayIndexOutOfBoundsException y cómo se puede evitar?
Es el error que ocurre cuando intentas acceder a un índice fuera de los límites (por ejemplo,
`arreglo[10]` en un arreglo de tamaño 10).
Se evita siempre usando `i < [Link]` en los ciclos y validando índices antes de
acceder.
¿Cómo funciona el ciclo “for-each” (bucle mejorado) en Processing y cuándo es mejor
usarlo?
```processing
For (int valor : miArreglo) {
Println(valor); // “valor” toma cada elemento uno por uno
}
```
Es más limpio y legible cuando no necesitas el índice. Úsalo para leer o procesar
elementos. Usa el `for` tradicional cuando necesites modificar por índice o conocer la
posición.
4. Uso Avanzado y Contexto Gráfico (Aplicación en Processing)
¿Cómo se puede usar un arreglo para almacenar las coordenadas (x, y) de múltiples
objetos en movimiento?
Opciones comunes:
- Dos arreglos paralelos: `float[] x = new float[100]; float[] y = new float[100];`
- Mejor: Un arreglo de objetos `PVector` (recomendado en Processing).
```processing
PVector[] particulas = new PVector[100];
For (int i = 0; i < [Link]; i++) {
Particulas[i] = new PVector(random(width), random(height));
}
```
Luego en `draw()` actualizas y dibujas cada una.
¿Qué funciones nativas de Processing existen para manipular arreglos?
Processing proporciona varias funciones útiles:
- `append(array, value)` → Agrega un elemento (devuelve un nuevo arreglo).
- `shorten(array)` → Elimina el último elemento.
- `expand(array)` o `expand(array, newSize)` → Aumenta el tamaño.
- `sort(array)` → Ordena el arreglo.
- `concat(array1, array2)` → Une dos arreglos.
¿Cuál es la diferencia entre un arreglo tradicional y un ArrayList en Processing, y cuándo
elegir uno sobre el otro?
- Arreglo tradicional: Tamaño fijo (o semi-fijo con `expand()`), más rápido, puede almacenar
tipos primitivos (`int`, `float`).
- ArrayList: Tamaño dinámico (agrega/elimina elementos fácilmente con `.add()`,
`.remove()`), más flexible, pero solo almacena objetos (usa `ArrayList<Integer>` para
enteros).
Elige arreglo cuando sabes aproximadamente cuántos elementos tendrás y buscas máximo
rendimiento.
Elige ArrayList cuando el número de elementos cambia mucho (añades/quitas partículas
constantemente).