Arreglos en java

Un arreglo o array en Java es una estructura de datos que permite almacenar una colección de
elementos, todos del mismo tipo, en una única variable. Los elementos de un array están
organizados secuencialmente en memoria, y se pueden acceder a través de índices numéricos,
comenzando por el índice 0 para el primer elemento, 1 para el segundo, y así sucesivamente.
Los arreglos son objetos en Java y tienen un tamaño fijo una vez que son creados.

Ventajas de utilizar arrays:

 Permiten almacenar múltiples elementos del mismo tipo en una única variable.
 Facilitan la organización y el manejo de conjuntos de datos relacionados.
 Ofrecen un acceso rápido y eficiente a los elementos mediante índices numéricos.
 Mejoran la legibilidad y la estructura del código al agrupar datos relacionados.

Algunos de los métodos más comunes en los arreglos son:

 length: devuelve el número de elementos en el arreglo.
 sort: ordena los elementos del arreglo.
 fill: rellena el arreglo con un valor específico.
 toString: devuelve una representación en cadena del arreglo.

Creación de arrays en Java

Crear un array en Java implica tres pasos: declarar la variable del array, asignarle memoria y,
opcionalmente, inicializar sus elementos.

a) Declaración de arrays
Para declarar un array, utilizamos la siguiente sintaxis:

tipo_de_dato[] nombre_del_array;

1. int[] numeros; // Declarando un array de enteros llamado "numeros"

2. String[] palabras; // Declarando un array de cadenas llamado "palabras"
 b) Asignación de memoria
Después de declarar el array, es necesario asignarle memoria, especificando su tamaño con la
palabra clave new. La sintaxis es:

nombre_del_array = new tipo_de_dato[tamaño];

números = new int[5]; // Asignando memoria para 5 elementos enteros en el array "numeros"
palabras = new String[3]; // Asignando memoria para 3 elementos de cadena en el array "palabras"

//-------------EN UNA SOLA LINEA

int[] numeros = new int[5]; // Declarando y asignando memoria al array "numeros"

String[] palabras = new String[3]; // Declarando y asignando memoria al array "palabras

c) Inicialización de arrays
Podemos inicializar los elementos del array de varias maneras

1) Inicialización individual de elementos:

numeros[0] = 10; // Asignando el valor 10 al primer elemento del array "numeros"

numeros[1] = 20; // Asignando el valor 20 al segundo elemento // ...

palabras[0] = "Hola"; // Asignando la cadena "Hola" al primer elemento del array "palabras"
palabras[1] = "Mundo"; // Asignando la cadena "Mundo" al segundo elemento

2) Inicialización durante la declaración:

int[] numeros = {1, 2, 3, 4, 5}; // Declarando, asignando memoria e inicializando el array

"numeros" con valores

String[] palabras = {"Java", "Array", "Ejemplo"}; // Declarando, asignando memoria e

inicializando el array "palabras" con cadenas

3) Inicialización usando bucles:

for (int i = 0; i < numeros.length; i++) {

numeros[i] = i * 10; // Asignando valores múltiplos de 10 a los elementos del array "numeros"
}

for (int i = 0; i < palabras.length; i++) {

palabras[i] = "Palabra " + (i + 1); // Asignando "Palabra 1", "Palabra 2",.. a los elementos
del array "palabras"

}
La creación de un array en Java implica declarar la variable del array, asignarle memoria y,
opcionalmente, inicializar sus elementos. La comprensión de estos pasos es fundamental para
trabajar con arrays y organizar datos en nuestros programas de manera eficiente.
EJERCICIO 1.- Crear un arreglo de números enteros

Public class Ejercicio1 {

public static void main(String[] args) {
int[] edades = new int[5]; // Definir arreglo de 5 elementos
// Establecer elementos
edades[0] = 23;
edades[1] = 50;
edades[2] = 80;
edades[3] = 18;
edades[4] = 20;
// Recorremos
for (int x = 0; x < edades.length; x++) {
System.out.printf("Edades[%d] = %d\n", x, edades[x]);
}
}

EJERCICIO 2.- Crear un arreglo con char, string

public class Ejercicio2 {

public static void main(String[]args){
String nombres []={"Victor", "Ronald","Carolina","Paola"};
int edad []={25,30,19,22};
char sexo []={'M','M','M','F'};
System.out.println("Datos de los usuarios");
System.out.println("NOMBRES EDAD SEXO");
System.out.println("------- ---- ----");
for (int u=0;u<nombres.length;u++){
System.out.println(nombres[u]+ " "+ edad[u] + " " + sexo[u]);

}
 Tipos de arrays en Java
En Java, podemos crear arrays de diferentes tipos, como arrays de tipos primitivos, arrays de
objetos y clases, y arrays multidimensionales.
A continuación, se presenta una descripción de cada uno de estos tipos, junto con ejemplos
detallados.

a) Arrays de tipos primitivos

Los arrays de tipos primitivos permiten almacenar elementos de tipos básicos como int, double,
char, boolean, etc.
Ejemplos:

int[] numeros = new int[5]; // Array de enteros

double[] precios = new double[3]; // Array de números decimales (double)

char[] letras = new char[10]; // Array de caracteres

boolean[] banderas = new boolean[2]; // Array de valores booleanos (verdadero/falso)

b) Arrays de objetos y clases

Los arrays de objetos y clases permiten almacenar elementos que son instancias de clases
personalizadas o clases predefinidas de Java, como String, Integer, Double, etc.

a. Ejemplo: Array de objetos de la clase String:

String[] nombres = new String[4]; // Array de objetos de la clase String

nombres[0] = "Alice";

nombres[1] = "Bob";

nombres[2] = "Carol";

nombres[3] = "David";

b. Ejemplo – Array de objetos de una clase personalizada (Estudiante):

class Estudiante {
String nombre;
int edad;
Estudiante(String nombre, int edad) {
this.nombre = nombre;
this.edad = edad;
}
}
// Creación de un array de objetos de la clase Estudiante
Estudiante[] estudiantes = new Estudiante[3];
estudiantes[0] = new Estudiante("Juan", 20);
estudiantes[1] = new Estudiante("Ana", 22);

estudiantes[2] = new Estudiante("Luis", 19);

 EJERCICIO 3.- Crear un arreglo de clases
public class Main
{
public static void main(String[] args) {
System.out.println("Registro de Clientes");
Cliente [] arr = new Cliente [3];
arr[0] = new Cliente (709270, "Roberto");
arr[1] = new Cliente (709219, "Liliana");
arr[0].display();
arr[1].display();
}
}
class Cliente{
public int id;
public String name;

Cliente (int id, String name) {

this.id = id;
this.name = name;
}
public void display() {
System.out.println("Id Cliente: " + id + " " + "Nombre del Cliente: " + name);
}
}

Ejemplo 4
public class Main
{
public static void main(String[] args) {
System.out.println("Registro de estudiantes");
// Creació de objetos de la clase Estudiante
Estudiante[] estudiantes = new Estudiante[3];
estudiantes[0] = new Estudiante("Juan", 20);
estudiantes[1] = new Estudiante("Ana", 22);
estudiantes[2] = new Estudiante("Luis", 19);

for(int i=0; i<estudiantes.length; i++){

estudiantes[i].display();
}}
}
class Estudiante {
String nombre;
int edad;
Estudiante(String nombre, int edad) {
this.nombre = nombre;
this.edad = edad; }
public void display() {
System.out.println("Nombre: " +nombre + " " + "Edad: " + edad);
}}
 Acceso a elementos de un array en Java
Para acceder a los elementos de un array en Java, utilizamos índices numéricos. Los índices en un
array comienzan en 0 para el primer elemento, 1 para el segundo y así sucesivamente hasta la
longitud del array menos 1 para el último elemento. A continuación, se muestran ejemplos de
cómo acceder a los elementos de diferentes tipos de arrays.

a) Acceso a elementos de un array de tipos primitivos

int[] numeros = {10, 20, 30, 40, 50};

int primerNumero = numeros[0]; // Accediendo al primer elemento del array

int segundoNumero = numeros[1]; // Accediendo al segundo elemento del array

int ultimoNumero = numeros[numeros.length - 1];// Accediendo al último elemento del array

System.out.println("Primer número: " + primerNumero);

System.out.println("Segundo número: " + segundoNumero);

System.out.println("Último número: " + ultimoNumero);

b) Acceso a elementos de un array de objetos y clases

String[] nombres = {"Alice", "Bob", "Carol", "David"};

String primerNombre = nombres[0]; // Accediendo al primer elemento del array

String segundoNombre = nombres[1]; // Accediendo al segundo elemento del array

String ultimoNombre = nombres[nombres.length - 1]; // Accediendo al último elemento del

array

System.out.println("Primer nombre: " + primerNombre);

System.out.println("Segundo nombre: " + segundoNombre);

System.out.println("Último nombre: " + ultimoNombre);

 Obtener la longitud de un array
Para obtener la longitud de un array (es decir, la cantidad de elementos que contiene), utilizamos
la propiedad length.
Ejemplo:
int[] numeros = {10, 20, 30, 40, 50};

int longitud = numeros.length; // Obteniendo la longitud del array "numeros"

System.out.println("La longitud del array 'numeros' es: " + longitud);

Ejercicios de

a. Diseña un programa que llene un array con 10 números enteros que se leen por teclado,
posteriormente debe calcular y mostrar el promedio de los valores.

b. Diseña un programa que registre el nombre y calificaciones de n estudiantes, de los cuales

debe mostrar, cuantos aprobaron, cuantos reprobaron y quien obtuvo la calificación más
alta, los datos se deben solicitar por teclado.

c. En una papelería se desea implementar una aplicación para calcular la venta de productos,
Al iniciar el sistema debe preguntar el número de artículos a introducir, luego debe
solicitar el precio de cada artículo, si un artículo tiene un costo mayor a 100 tiene un 20%
de descuento, Al final la aplicación debe mostrar el total de la Venta con descuento y con
descuento.