3. Arreglos Unidimensionales

LOGRO DE LA UNIDAD DE APRENDIZAJE

Al término de este post, ustedes manipulan arreglos unidimensionales y bidimensionales con tipos primitivos, así como arreglo de objetos en diversas aplicaciones.

TEMARIO

· Arreglos unidimensionales

· Operaciones variadas

ACTIVIDADES PROPUESTAS

· Ustedes reconocen un arreglo unidimensional.
· Ustedes emplean arreglos unidimensionales en diversas aplicaciones.

1. ARREGLO UNIDIMENSIONAL

Un arreglo es un conjunto de elementos dispuestos uno a continuación de otro, donde cada elemento conserva su propio espacio (tamaño en bytes).

El espacio ocupado por cada elemento es igual para todos y, en él, se pueden almacenar diferentes valores,pero del mismo tipo de dato.

El tipo más simple de un arreglo es el unidimensional.

a) Declaración:

Forma 1:

tipo_dato nombre_arreglo[];

ejemplos:

int n[];
double sueldos[];
String apellidos[];

Forma 2:

tipo_dato[] nombre_arreglo;

ejemplos:

int[] n;
double[] sueldos;
String[] apellidos;

Con la declaración sólo se crea la variable que hace referencia al arreglo y su contenido es null.

b) Creación:

nombre_arreglo = new tipo[tamaño];

ejemplos:

n = new int [10];
sueldos = new double[8];
apellidos = new String[12];

Con la creación le indicamos a Java la cantidad de elementos que va a tener el arreglo (tamaño del bloque de elementos) y la variable que hace referencia al arreglo almacena la dirección del primer elemento del arreglo.

c) Declaración y creación en la misma linea:

tipo_dato nombre_arreglo[] = new tipo_dato[tamaño];

ejemplos:

int n[] = new int[7];

gráficamente:

Consideraciones:

. Java, por defecto, inicializa un arreglo de tipo int con 0, un arreglo de tipo double con 0.0, un arreglo de tipo String con null y un arreglo de tipo boolean con false.
. Java cuenta las posiciones a partir de 0
. Esta posición se denomina indice: i
. Los siete elementos del arreglo n son: n[0], n[1], n[2], n[3], n[4], n[5], n[6]
. n[7] no está definido
. n.length devuelve el tamaño del arreglo (en este caso, 7)
. El indice i se encuentra en el rango: 0 <= i < n.length

d) Inicialización: Se puede inicializar un arreglo con números aleatorios de la siguiente forma:

void generar() {
   for(int i=0; i< n.length ; i++)
      n[i]=aleatorio(10,99);
}
int aleatorio (int min, int max) {
   return (int)((max - min + 1) * Math.random()+ min);
}

e) Declaración, creación e inicialización: Se puede declarar, crear e inicializar un arreglo en una misma linea de la siguiente forma:

tipo_de_dato nombre_del_arreglo[]={valor1, valor2, ...};

Ejemplos:

int n[]={1,12,0,-5,25};
String nombres[]= {”Juan”,”Pedro”,”Ana”};

2. OPERACIONES VARIADAS 

Ejemplo 1 

Este ejemplo esta compuesto de 2 clases: la clase ArregloUnidimensional (clase que maneja el arreglo) y la clase Principal (clase que interactúa con el usuario através de la GUI). 


Código de la clase ArregloUnidimensional

Podemos apreciar que la clase ArregloUnidimensional tiene 2 atributos privados

- Un arreglo de edades de tipo int

- La variable indice de tipo int, que almacena la cantidad de edades ingresadas y la posición del arreglo donde se almacenará una nueva edad.

Descripción de métodos

- El método constructor se encarga de crear el arreglo con 10 elementos e inicializa la variable indice en cero ya que el arreglo esta vacío.
- El método adicionar se encarga de almacenar la edad en el arreglo e incrementa la variable indice en uno.
- El método getIndice es un método de acceso para el atributo índice, ya que éste es privado. Devuelve la cantidad de edades ingresadas.
- El método longTotal devuelve la longitud total de todo el arreglo
- El método obtener devuelve la edad que se encuentra en el arreglo en la posición pos, ya que desde afuera de la clase no se tiene acceso al arreglo por ser privado.
- El método reinicializar crea un nuevo bloque de 10 elementos de tipo int y se almacena en la variable edades la referencia o dirección de éste nuevo bloque de elementos perdiéndose la dirección del bloque anterior. El garbage collector se encargará de destruir el bloque anterior.
- El método generar llena el arreglo de números aleatorios de 2 cifras.
- El método buscar localiza una edad y devuelve la posición donde lo encontró. Si la edad no existe, devuelve -1, que es un indicador de no encontrado.
- Los métodos sumaEdades, edadMenor, edadMayor y edadPromedio son métodos de cálculo.

Código de la clase Principal

import java.awt.event.*;
import java.awt.*;
import javax.swing.*;

public class Problema01b extends JApplet implements ActionListener{
 
 // Declaración de variables globales para la GUI
 JButton btnProcesar, btnBorrar;
 JTextArea txtS;
 JComboBox choCategoria;
 JLabel lblCategoria, lblPromedio;
 JTextField txtPromedio;
 JScrollPane scpScroll;
 
 // Declaración de variables globales para el algoritmo
 int categoria;
 double actualpen, nuevapen, descuento, promedio;

 // -----------------------------------------------------------------------
 // Crea la interfaz gráfica de usuario GUI
 public void init() {
  getContentPane().setLayout(null);
  
  setBackground(new Color(214,211,206));
 
  txtPromedio = new JTextField();
  txtPromedio.setBounds(79, 40, 87, 23);
  getContentPane().add(txtPromedio);
  
  btnProcesar = new JButton("Procesar");
  btnProcesar.setBounds(305, 15, 101, 23);
  btnProcesar.addActionListener(this);
  getContentPane().add(btnProcesar);
  
  btnBorrar = new JButton("Borrar");
  btnBorrar.setBounds(305, 39, 101, 23);
  btnBorrar.addActionListener(this);
  getContentPane().add(btnBorrar);
  
  choCategoria = new JComboBox();
  choCategoria.setBounds(79, 15, 87, 23);
  choCategoria.addItem("A");
  choCategoria.addItem("B");
  choCategoria.addItem("C");
  choCategoria.addItem("D");
  getContentPane().add(choCategoria);
  
  lblCategoria = new JLabel("Categoría");
  lblCategoria.setBounds(15, 15, 61, 23);
  getContentPane().add(lblCategoria);
 
  lblPromedio = new JLabel("Promedio");
  lblPromedio.setBounds(15, 40, 56, 23);
  getContentPane().add(lblPromedio);
  
  txtS = new JTextArea();
  txtS.setFont(new Font("monospaced", 0, 12));
  
  scpScroll = new JScrollPane(txtS);
  scpScroll.setBounds(15, 75, 394, 75);
  getContentPane().add(scpScroll);
  
 }
 
 // -----------------------------------------------------------------------
 // Procesa eventos de tipo ActionEvent
 public void actionPerformed( ActionEvent e ){
  // Si hizo clic en Procesar
  if( e.getSource() == btnProcesar )
   procesar();
  
  // Si hizo clic en Borrar
  if( e.getSource() == btnBorrar )
   borrar();
 }
 
 // -----------------------------------------------------------------------
 // Método del botón Procesar
 void procesar(){
  // Entrada de datos
  categoria = getCategoria();
  promedio = getPromedio();
  
  // Proceso de cálculo
  actualpen = calcularPensionActual(categoria);
  descuento = calcularDescuento(promedio, actualpen);
  nuevapen = calcularNuevaPension(actualpen, descuento);
  
  // Salida de resultados
  txtS.setText("");
  imprimir("Pensión actual : " + actualpen);
  imprimir("Descuento : " + descuento);
  imprimir("Nueva pensión : " + nuevapen);
 }
 // -----------------------------------------------------------------------
 // Método del botón Borrar
 void borrar(){
  txtS.setText("");
  txtPromedio.setText("");
  txtPromedio.requestFocus();
 }

 // -----------------------------------------------------------------------
 // Lee y retorna la categoría
 int getCategoria(){
  return choCategoria.getSelectedIndex();
 }
 // -----------------------------------------------------------------------
 // Lee y retorna el promedio
 double getPromedio(){
  return Double.parseDouble(txtPromedio.getText());
 }
 // -----------------------------------------------------------------------
 // Calcula y retorna la pensión actual
 double calcularPensionActual(int categoria){
  switch(categoria){
   case 0 : return 550;
   case 1 : return 500;
   case 2 : return 460;
   default: return 400;
  }
 }
 // -----------------------------------------------------------------------
 // Cálcula el descuento
 double calcularDescuento(double promedio, double actualpen){
  if(promedio <= 13.99)
   return 0;
  else if(promedio <= 15.99)
   return 0.10*actualpen;
  else if(promedio <= 17.99)
   return 0.12*actualpen;
  else
   return 0.15*actualpen;
 }
 // -----------------------------------------------------------------------
 // Calcula la nueva pensión
 double calcularNuevaPension(double actualpen, double descuento){
  return actualpen - descuento;
 }
 // -----------------------------------------------------------------------
 // Imprime una cadena de texto incluyendo un salto de línea al final
 void imprimir(String cad){
  txtS.append(cad + "\n");
 }

}

GUI del Ejemplo 1:

Ejemplo 2 

Cree un método que permita adicionar edades en forma ilimitada, es decir, que si el arreglo edades se llena, éste se amplie.

En la clase ArregloUnidimensional:


En la clase principal:


Ejemplo 3

Cree un método que permita ordenar en forma ascendente el arreglo de edades.

En la clase ArregloUnidimensional:


En la clase Principal:


Descargar ejercicios:
Descargar archivo

Preguntas:

¿Qué es un arreglo unidimensional?

¿Cómo se crea un arreglo unidimensional?

¿Cómo inicializar un arreglo unidimensional?

Operaciones variadas en un arreglo unidimensional
¿Qué es el garbage collector?