Download Estructuras de datos en Java

Estructuras de datos en Java
Estructuras de datos en Java
Luis Felipe Wanumen Silva
Laura Ximena García Vaca
Darín Jairo Mosquera Palacios
Dirigido a estudiantes de ingeniería, tecnólogos y técnicos en programación
© Universidad Distrital Francisco José de Caldas
©Facultad de Tecnología
©Luis Felipe Wanumen Silva, Laura Ximena García Vaca,
Darín Jairo Mosquera Palacios
Primera edición, abril de 2017
ISBN: 978-958-5434-19-6
Dirección Sección de Publicaciones
Rubén Eliécer Carvajalino C.
Coordinación editorial
Nathalie De la Cuadra N.
Corrección de estilo
Lilia Carvajal Ahumada
Diagramación
Astrid Prieto Castillo
Editorial UD
Universidad Distrital Francisco José de Caldas
Carrera 24 No. 34-37
Teléfono: 3239300 ext. 6202
Correo electrónico: [email protected]
Estructuras de datos en Java / Darín Jairo Mosquera Palacios y
otros. -- Bogotá: Universidad Distrital Francisco José de
Caldas, 2017.
234 páginas ; 24 cm.
ISBN 978-958-5434-19-6
Ingeniería de sistemas 2. Java (Lenguaje de programación
de computadores) 3. Lenguajes de programación (Computadores)
1. Mosquera Palacios, Darín Jairo, autor.
005.133 cd 21 ed.
A1568625
CEP-Banco de la República-Biblioteca Luis Ángel Arango
Todos los derechos reservados.
Esta obra no puede ser reproducida sin el permiso previo escrito de la
Sección de Publicaciones de la Universidad Distrital.
Hecho en Colombia
Contenido
Introducción...............................................................................13
Tipos abstractos de datos................................................................15
Concepto de TAD....................................................................................... 15
Concepto de estructuras.............................................................................. 15
Estructuras estáticas de datos: arreglos, vectores o arrays.......................19
Introducción a los arreglos.......................................................................... 19
Impresión del contenido de un arreglo......................................................... 21
Problemas con dimensiones de arreglos y utilización de length..................... 21
Cómo llenar un vector posición por posición................................................ 22
Tablas de multiplicar................................................................................... 24
Arreglos con tamaño predeterminado.......................................................... 24
Arreglos tipo integer.................................................................................... 26
Arreglos string............................................................................................ 26
Uso de las referencias a arreglos.................................................................. 27
Referencias y arrays.................................................................................... 28
Punteros C/C++ y referencias Java............................................................. 29
Ordenar un vector....................................................................................... 30
Suma de posiciones pares e impares............................................................. 31
Búsqueda en un vector desordenado............................................................ 33
Prueba de escritorio.................................................................................... 35
Ordenar un arreglo de string con collection.................................................. 39
Definir y utilizar vectores dinámicos............................................................ 40
Ejercicios.................................................................................................... 41
Estructuras estáticas de datos: matrices.............................................45
Creación, inicio e impresión de matriz tipo int y no dinámica....................... 45
Creación, inicio e impresión de matriz tipo int y dinámica........................... 46
Programa que pide cada uno de los valores de una matriz............................ 47
Programa que calcula la transpuesta de una matriz...................................... 50
Matriz mágica............................................................................................ 55
Matriz de TextField..................................................................................... 58
Triangulares y diagonales de una matriz...................................................... 61
Programa que pone 15 minas en una matriz................................................. 63
Ejercicios ................................................................................................... 65
Estructuras dinámicas de datos: listas en Java......................................67
Concepto de lista........................................................................................ 67
Primera lista lineal en Java.......................................................................... 68
Ejemplo de listas lineales en Java................................................................. 71
Captura y visualización de datos de una lista............................................... 76
Listas lineales con nodo cabeza de control vacío.......................................... 79
Inserción de datos en una lista en un nodo específico................................... 82
Ejercicios ................................................................................................... 91
Listas sencillas circulares...............................................................93
Concepto de listas circulares........................................................................ 93
Listas circulares con nodo cabeza de control................................................ 96
Lista sencilla con tamaño dado por el usuario.............................................. 98
Ejercicios ................................................................................................... 100
Pilas en Java...............................................................................103
Concepto de pila......................................................................................... 103
Ejemplo conceptual de pila......................................................................... 103
Funciones push y pop de la clase stack......................................................... 105
Uso de la funcion peek de la clase stack....................................................... 109
Uso de la función boolean empty de la clase stack........................................ 111
Uso de la función int search de la clase stack................................................ 112
Ejercicios ................................................................................................... 114
Teoría sobre árboles binarios...........................................................115
Definición de árboles binarios..................................................................... 115
Nodos no terminales y terminales................................................................ 116
Hoja........................................................................................................... 116
Camino...................................................................................................... 117
Longitud..................................................................................................... 118
Ejercicios.................................................................................................... 119
Algoritmos básicos sobre árboles binarios...........................................121
Imprimir un árbol binario llenado forzadamente.......................................... 121
Árbol binario sin recursividad...................................................................... 127
Ejercicios.................................................................................................... 134
Recorrido en árboles binarios..........................................................135
Conceptos.................................................................................................. 135
Árbol binario: pre- in- y posorden y llenado por el usuario............................ 136
Ejercicios ................................................................................................... 146
Aplicaciones sobre árboles binarios...................................................147
Establecer si dos árboles binarios son iguales............................................... 147
Algoritmo de solución................................................................................. 148
Contar los nodos en árboles binarios............................................................ 150
Algoritmo de solución................................................................................. 150
Determinar si dos árboles binarios son semejantes....................................... 152
Algoritmo de solución................................................................................. 153
Determinar si dos árboles binarios son isomorfos......................................... 155
Determinar la altura de un árbol binario...................................................... 156
Determinar si un árbol binario es completo.................................................. 159
Ver si un árbol binario es completo y lleno a la vez....................................... 172
Crear y graficar un árbol binario.................................................................. 181
Ejercicios ................................................................................................... 187
Árboles jerárquicos en Java.............................................................189
Agregar hijos al árbol.................................................................................. 190
Mostrar texto del último nodo seleccionado................................................. 192
Dejar visible el último nodo seleccionado.................................................... 197
Poner manipulador de nodo raíz.................................................................. 201
Mostrar y ocultar el nodo raíz..................................................................... 203
Poner y retirar el foco en el árbol................................................................. 207
Ejercicios.................................................................................................... 209
Conceptos sobre grafos..................................................................211
Definicion de grafo..................................................................................... 211
Lazos......................................................................................................... 212
Aristas múltiples......................................................................................... 212
Grado de un vértice.................................................................................... 213
Notación de vértices y aristas...................................................................... 214
Vértices adyacentes..................................................................................... 216
Creación de un grafo en Java....................................................................... 217
Ejercicios ................................................................................................... 232
Bibliografía................................................................................233
Introducción
Las notas de clase del curso Estructuras de Datos ofrecen al lector una exposición
clara de los conceptos básicos de estructuras y árboles. Para el desarrollo de este
curso se supone que el lector ya está familiarizado con fundamentos de Java como
las variables, los autónomos y applets, las principales clases que encapsulan tipos
primitivos, las cuestiones básicas de la interfaz gráfica, etc.
Se dedican especiales esfuerzos a explicar las listas, debido a que este es el primer
tema que muchos profesores y autores de libros tratan en cursos de estructuras en
cualquier lenguaje de programación.
Por otra parte, se muestra el manejo de las pilas por medio de la clase stack,
que incopora Java y que ayuda indudablemente a que este no sea en sí un tema
tan complicado como en otros lenguajes. Asimismo, se muestran ampliamente los
conceptos y el uso de árboles binarios.
El documento se estructura por capítulos siguiendo una lógica académica. Se
parte de los conceptos básicos de tipos abstractos de datos en el capítulo uno, de tal
suerte que con ello se obtiene una visión sobre las estructuras de datos.
En el segundo capítulo se profundiza en el manejo y creación de estructuras de
datos estáticas entre las que se encuentran los arreglos. Este tipo de datos se tratan debido a que técnicamente son estructura de datos. Algunos autores no incluyen estos
temas porque consideran que el estudiante ha visto y conoce las estructuras estáticas,
sin embargo incluirlos ayuda a conseguir las habilidades necesarias para comprender
cualquier texto inicial de estructuras de datos.
El tercer capítulo profundiza en la estructura de datos estática llamada «matriz»,
con el ánimo de mejorar la algoritmia del lector y de permitir que adquiera a través
de ejemplos la lógica de programación necesaria para afrontar los futuros usos que
las matrices tienen en estructuras de datos complejas como los grafos. Aunque este
es un tema avanzado y por lo tanto no se trata con amplitud, se dejan al lector los elementos necesarios para que pueda comprenderlos fácilmente cuando se enfrente a él.
Los capítulos cuatro y cinco tratan las listas, porque potencialmente pueden
tener los mismos usos que los vectores, y la forma como se implementan mejora el
rendimiento de las aplicaciones porque optimiza el uso de los recursos en relación
con estos.
13
Luis Felipe Wanumen Silva, Laura Ximena García Vaca, Darín Jairo Mosquera Palacios
El capítulo seis analiza las pilas. Para ello se aprovechan las API propias de Java
que permiten que el lector fácilmente las implemente. Se deja como tarea hacerlo
sin el uso de las API de Java. De igual manera se muestra cómo algunas estructuras
de datos son más rápidas de utilizar en lenguajes como Java si se compara con otros
como C o C++.
Los capítulos siete, ocho, nueve, diez y once tratan aspectos importantes sobre
los árboles binarios y las dos formas para implementarlos: la «artesanal», es decir,
usando toda la lógica de árboles desde cero, y el reuso de API, en el que se observan
algunas utilidades provistas por la plataforma Java para su manejo, y se aplica a fin
de dar al lector una visión sobre las posibilidades que ofrece Java para implementar
árboles binarios y n-arios. Hay que anotar que no se profundiza en los árboles n-arios
por ser este tema un tema digno de trabajar en un segundo libro de estructuras de
datos avanzadas.
El capítulo doce trabaja superficialmente los temas teóricos de grafos, sin embargo esto se hace a manera de introducción. Se plantean ejercicios para lograr que el
estudiante avance sobre ello de forma autodidacta.
14
Tipos abstractos de datos
Concepto de TAD
En una aplicación de software podemos diferenciar claramente dos aspectos importantes: la interfaz de usuario y los procesos internos de la aplicación.
La interfaz de usuario en realidad es la parte más importante a corto tiempo
para lograr que la aplicación sea atractiva al usuario. Pero a largo plazo lo único que
garantiza que la aplicación perdure es la forma como se implementan sus procesos
internos, ello requiere algunas operaciones y unas estructuras que serán las encargadas de almacenar la información sobre la cual se van a realizar las operaciones. Una
muy buena alternativa para modelar software son los objetos abstractos que incluyan
operaciones y estructuras en entes autónomos, autosuficientes y cerrados. Estos entes
se conocen como tipos abstractos de datos (TAD).
Concepto de estructuras
En Java existen algunas formas simples de almacenar información. La primera es utilizando variables. Era en estas pequeñas áreas de memoria referenciadas por dichas
variables en donde se almacenaban algunos datos. Por el tipo de datos tan primitivos
que se pueden almacenar, se denominaban “variables de tipos primitivos de datos”.
Con la llegada de lenguajes adelantados en programación orientados a objetos,
se pensó en crear formas de almacenar y contener tipos primitivos de datos —que
sirvieran como capa envolvente para encapsular también operaciones de conversión
sobre estos datos—, y que se les denominó “objetos de tipos de datos”.
Ahora bien, tanto para el caso de “tipos primitivos de datos” como para el caso
de “objetos de tipos de datos”, se pueden construir estructuras más complejas que
permitan crear arreglos de múltiples dimensiones basados en tipos primitivos o en
objetos de tipos de datos. Recordemos por ejemplo que en Java una forma de crear
una estructura compuesta de tres dimensiones asociada con la variable “tabla” y donde la primera dimensión tiene un tamaño máximo de 4, la segunda de 6 y la tercera
de 5 es la siguiente:
int tabla[][][] = new int[4][6][5];
15
Luis Felipe Wanumen Silva, Laura Ximena García Vaca, Darín Jairo Mosquera Palacios
A este tipo de implementaciones se les conoce con el nombre de estructuras compuestas, sin embargo a pesar de las ventajas que presenta trabajar con ellas, en algunos casos se necesita una representación más amplia de dicha estructura, en la cual
sea posible añadir un elemento en medio de unos dos elementos específicos, y que
la memoria utilizada por el mismo elemento sea liberada en tiempo de ejecución de
la aplicación. Para lograr estas facilidades tenemos que recurrir a estructuras mucho
más completas y dinámicas, es decir, que puedan adquirirse recursos de memoria
cuando se necesiten y viceversa, que estos puedan eliminarse cuando no sean necesarios.
Tenemos una primera clasificación de las estructuras de datos en “estructuras
estáticas de datos” y en “estructuras de datos dinámicas”.
Estructura de datos
Estructura estadística de datos
Estructura de datos dinámica
Surge entonces el concepto de estructuras dinámicas, que no son más que la colección de varios elementos abstractos de datos autónomos en forma relacionada. A
dichos elementos se les denomina por lo general “nodos de la estructura”.
Veamos de forma gráfica todo lo expuesto anteriormente:
“N” Nodos relacionados entre sí
Nodo D
Estructura
dinámica
Nodo A
Nodo F
Nodo I
Nodo B
Nodo G
Nodo E
Nodo X
Nodo H
Nodo C
De acuerdo con el tipo de relaciones que tengan los nodos podremos especificar concretamente qué tipo de estructura dinámica es. En el siguiente gráfico se muestran
algunas de las más conocidas subdivisiones de las estructuras dinámicas.
16
Estructuras de datos en Java
Estructuras de datos
Lineales
Listas
Colas
No Lineales
Pilas
Árboles
Grafos
17
Estructuras estáticas de datos:
arreglos, vectores o arrays
Introducción a los arreglos
A los arreglos comúnmente se les denomina “arrays”, y también “vectores”. Por
experiencia podemos asegurar que son lo mismo. Se puso este item así con el fin de
lograr que el usuario de este material pueda encontrar fácilmente los temas, dependiendo de cómo le llame a los arreglos.
Los arreglos en Java son siempre dinámicos por lo que no es necesario que el
programador ponga la longitud. Es más, si lo hace se produce un error cuando se
compile el programa.
Forma correcta de declarar un arreglo
int arreglo[]
Forma incorrecta de declarar un arreglo
int arreglo[3]
Otra forma correcta de declarar un arreglo
int[] arreglo
En esta última forma usamos los corchetes en el tipo de dato de la variable. Para
comprender mejor esto veamos el ejemplo:
import java.awt.*;
import java.applet.*;
public class MyApp extends Applet
{
int arreglo[] = {25,14};
public void paint(Graphics g)
{
g.drawString(“Posición Cero: “+arreglo[0], 20, 20);
g.drawString(“Posición Uno: “+arreglo[1], 20, 40);
}
}
19
Luis Felipe Wanumen Silva, Laura Ximena García Vaca, Darín Jairo Mosquera Palacios
El programa anterior produce el siguiente resultado en el navegador:
Posición cero: 25
Posición uno: 14.
Observemos que si hubieramos reemplazado la línea de código:
int arreglo[] = {25,14};
por la línea de código
int arreglo[2] = {25,14};
se habría producido un error en la aplicación, debido a que estábamos tratando de
especificar con anterioridad la dimensión del arreglo, vector, array o como le llame
el estudiante.
En Java se pueden declarar arrays de cualquier tipo:
char s[];
int iArray[];
Incluso se pueden construir arrays de arrays:
int tabla[][] = new int[4][5];
Los límites de los arrays se comprueban en tiempo de ejecución para evitar desbordamientos y la corrupción de la memoria.
En Java un array es realmente un objeto, porque tiene redefinido el operador [].
Tiene una función miembro length. Se puede utilizar este método para conocer la
longitud de cualquier array.
int a[][] = new int[10][3];
a.length;
/* 10 */
a[0].length;
/* 3 */
Para crear un array en Java hay dos métodos básicos; crear uno vacío,
int lista[] = new int[50];
O con sus valores iniciales:
String nombres[] = {
“Juan”,”Pepe”,”Pedro”,”Maria”
};
Esto es equivalente a:
String nombres[];
nombres = new String[4];
nombres[0] = new String(
nombres[1] = new String(
nombres[2] = new String(
nombres[3] = new String(
“Juan” );
“Pepe” );
“Pedro” );
“Maria” );
No se pueden crear arrays estáticos en tiempo de compilación:
int lista[50];
// generará un error en tiempo de compilación
Tampoco se puede rellenar un array sin declarar el tamaño con el operador new:
int lista[];
for( int i=0; i < 9; i++ )
lista[i] = i;
20
Estructuras de datos en Java
Es decir, todos los arrays en Java son estáticos. Para convertir un array en el equivalente dinámico en C/C++, se usa la clase vector, que permite en él operaciones de
inserción, borrado, etc.
Impresión del contenido de un arreglo
Para lograr más claridad en los temas vistos, se plantea este programa:
import java.awt.*;
import java.applet.*;
public class MyApp extends Applet
{
int arreglo[] = {0,1,2,3,4,5,6,7,8,9,10},
max = 10, inicio, valor;
public void paint(Graphics g)
{
for (inicio = 0; inicio<=max; inicio++)
{
valor = 10*(inicio+1);
g.drawString(«arreglo[«+inicio+»] = «+arreglo[inicio],3, valor);
}
}
}
El cual arroja el siguiente resultado:
arreglo[0] = 0
arreglo[1] = 1
arreglo[2] = 2
arreglo[3] = 3
arreglo[4] = 4
arreglo[5] = 5
arreglo[6] = 6
arreglo[7] = 7
arreglo[8] = 8
arreglo[9] = 9
arreglo[10] = 10
Problemas con dimensiones de arreglos y utilización de length
Como se ha mencionado anteriormente en varias ocasiones, es posible definir un
arreglo mediante la instrucción:
int arreglo[] = new int[4];
Pero hay que tener un gran cuidado con esto en el momento de asignarle valores a
dicho arreglo, es decir, se le puede asignar valor a “arreglo[0]”, “arreglo[1]”, “arreglo[2]” y “arreglo[3]”, pero no es posible asignarle valores a “arreglo[4]”, debido a
que la longitud del arreglo es de 4. Para entenderlo mejor a continuación mostramos
un programa que presenta un problema y por lo tanto no alcanza a imprimir los valores del arreglo. Veamos:
21
Luis Felipe Wanumen Silva, Laura Ximena García Vaca, Darín Jairo Mosquera Palacios
import java.awt.*;
import java.applet.*;
public class MyApp extends Applet
{
int arreglo[] = new int[4];
public void paint(Graphics g)
{
for(int k = 0; k<5;k++){
arreglo[k]=k;
}
for(int h = 0; h<5;h++){
g.drawString(«arreglo[«+h+»]=»+arreglo[h],20,60+h*10);
}
}
}
Para corregirlo es necesario saber el tamaño del arreglo que se ha declarado, con
el fin de asignarle valores a posiciones del arreglo válidas. Esto se puede hacer mediante la función “length”, que captura el tamaño del arreglo. A continuación se
muestra la correción del ejercicio anterior:
import java.awt.*;
import java.applet.*;
public class MyApp extends Applet
{
int arreglo[] = new int[4];
public void paint(Graphics g)
{
g.drawString(«Hello World ee», 20, 20);
for(int k = 0; k<arreglo.length;k++){
arreglo[k]=k;
}
for(int h = 0; h<arreglo.length;h++){
g.drawString(«arreglo[«+h+»]=»+arreglo[h],20,60+h*10);
}
}
}
Cómo llenar un vector posición por posición
En algunos casos es posible que se quiera hacer un programa que vaya capturando
números o datos de forma cíclica, de tal suerte que al final del ciclo se haya llenado
un vector. Este ejercicio, pese a lo sencillo, es escaso de encontrar en textos de Java,
razón por la cual se expone a continuación con el fin de lograr que el lector tenga la
mayor cantidad de material para lograr variado tipo de aplicaciones. Veamos:
22
Estructuras de datos en Java
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class MyApp extends JFrame implements java.awt.event.ActionListener
{
JLabel label1 = new JLabel(«Digite Número»);
JTextField texto1 = new JTextField(10);
JButton boton1 = new JButton(«CAPTURAR»);
JTextField texto3 = new JTextField(10);
int x[]=new int [6];
int aux=0;
public MyApp()
{
this.addWindowListener(new WindowAdapter(){
public void windowClosing(WindowEvent e){
dispose();
System.exit(0);
}
});
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
getContentPane().setLayout(new GridLayout(2,2,20,20));
}
getContentPane().add(label1);
getContentPane().add(texto1);
getContentPane().add(boton1);
getContentPane().add(texto3);
texto3.setVisible(false);
boton1.addActionListener(this);
public void actionPerformed(ActionEvent ev)
{
if(ev.getSource()==boton1)
{ if(aux<6)
{
String aux2 = new String(texto1.getText());
String aux3 = new String(aux2.trim());
x[aux] = Integer.parseInt(aux3);
//x[aux]=Integer.parseInt(texto1.getText().trim());
texto1.setText(«»);
aux++;
} // Cierra while
} // Cierra if boton = boton1
if(aux==6){
texto1.setVisible(false);
texto3.setVisible(true);
texto3.setText(«»);
label1.setText(«El vector es:»);
for(int i=0; i<aux; i++){
String aux1 = new String(texto3.getText());
texto3.setText(aux1.concat(« «+x[i]));
boton1.setText(«FIN»);
}
23
Luis Felipe Wanumen Silva, Laura Ximena García Vaca, Darín Jairo Mosquera Palacios
}
} // Cierra actionPerformed()
public static void main(String args[])
{
System.out.println(«Starting App»);
MyApp f = new MyApp();
f.setSize(450,300);
f.show();
} // Cierra función main()
} // Cierra class MyApp
El programa espera que el usuario digite un número, después de lo cual debe presionar el botón “capturar” y repetir esta operación seis veces, luego se muestra en una
caja de texto adicional los valores previamente insertados, se deshabilita la caja de
texto inicial y se le cambia el texto al botón indicando que finalizó el programa1.
Tablas de multiplicar
import java.awt.*;
import java.applet.*;
public class MyApp extends Applet
{
int arreglo[];
int inicio, inicio1, valory, valorx, max =10;
public void paint(Graphics g)
{
g.drawString(«Programa: Tablas de Multiplicar», 20, 150);
g.drawString(«Elaborado por el profesor: «, 20, 160);
g.drawString(«Luis Felipe Wanumen Silva «, 20, 170);
g.drawString(«Para dictar clase «, 20, 180);
for(inicio=0; inicio<=max; inicio++){
valory = 10*(inicio+1);
g.drawString(«Tabla del «+inicio,valory*6-50,10);
for(inicio1=0; inicio1<=max; inicio1++){
valorx = 60*(inicio1+1);
g.drawString(«»+inicio1+»*»+inicio+»=»+(inicio1*inicio),valorx-50,valory+20);
}
}
}
}
Arreglos con tamaño predeterminado
En secciones anteriores veíamos que era imposible escribir líneas como esta:
int arreglo[2] = {25,14};
1
Más ejercicios sobre este tipo de estructuras estáticas se pueden encontrar en [1].
24
Estructuras de datos en Java
Ello se debe básicamente a que en Java todas las variables son dinámicas, pero se
puede hacer de la siguiente manera:
int[] miarreglo = new int[5];
A continuación se muestra un programilla applet que utiliza esta forma de crear un
arreglo con una longitud predeterminada y posteriormente le pone e imprime su
contenido mediante un ciclo for. Veamos pues:
import java.awt.*;
import java.applet.*;
public class MyApp extends Applet
{
int[] miarreglo = new int[5];
public void paint(Graphics g)
{
for (int k = 0; k < miarreglo.length; k++) {
miarreglo[k] = k;
g.drawString(«[k] = « + miarreglo[k], 20, (k+10)*k);
}
}
}
Cabe anotar que el manejo para los arreglos de tipo flota, doble, es similar al anterior,
así que no creo que merezcan especial atención, no obstante a continuación se muestra un programa en el que se hacen arreglos de este tipo, con el fin de lograr claridad
sobre ello.
import java.awt.*;
import java.applet.*;
public class MyApp extends Applet
{
double[] miarreglo_double = new double[7];
float[] miarreglo_float = new float[7];
long[] miarreglo_long = new long[7];
public void paint(Graphics g)
{
for (int k = 0; k < miarreglo_double.length; k++) {
miarreglo_double[k] = k;
miarreglo_float[k] = miarreglo_float.length - k;
miarreglo_long[k] = (miarreglo_float.length - k)*2;
g.drawString(«[k] = « + miarreglo_double[k], 20,
(k+10)*k);
g.drawString(«[k] = « + miarreglo_float[k], 60, (k+10)*k);
g.drawString(«[k] = « + miarreglo_long[k], 100, (k+10)*k);
}
}
}
Bueno, ahora usted, amigo lector, se preguntará, ¿qué pasa con los arreglos de string?
Dado que los string son objetos y un string no es un dato primitivo, sino un tipo de
objeto de dato, tenemos que tratarlo de forma diferente. Por ello más adelante se
estudiará con detalle.
25
Luis Felipe Wanumen Silva, Laura Ximena García Vaca, Darín Jairo Mosquera Palacios
Arreglos tipo integer
Los arreglos tipo integer son diferentes a los int básicamente en concepto, debido a
que los primeros son de objetos integer y los segundos son de variables int; de todas
formas los int por el simple hecho de ser arreglos ya tienen comportamientos de objeto y esto queda claro cuando se utiliza la función “length” en un arreglo tipo “int”,
tal como se muestra a continuación:
int arreglo[] = new int[4];
for(int k = 0; k<arreglo.length;k++){
arreglo[k]=k;
}
Ahora bien, fijémonos en que la asignación se hace directamente sobre la posición
que se quiera del arreglo, cosa que varía notablemente en los arreglos tipo “integer”,
en los cuales la asignación se hace mediante la palabra reservada “new”. Para
comprender mejor esto, veamos el siguiente programa applet de ejemplo:
import java.awt.*;
import java.applet.*;
public class MyApp extends Applet
{
Integer arreglo[] = new Integer [4];
public void paint(Graphics g)
{
g.drawString(«Hello World ee», 20, 20);
for(int k = 0; k<arreglo.length;k++){
arreglo[k]= new Integer(k);
}
for(int h = 0; h<arreglo.length;h++){
g.drawString(«arreglo[«+h+»]=»+arreglo[h],20,60+h*10);
}
}
}
Arreglos string
Estabamos estudiando los arreglos de algunos tipos como int, long, flota y double,
pero ahora veamos como son los del tipo string.
Empecemos por decir que para declarar un array de string se escribe:
String[] arraydeobjetosString = new String[3];
La gran diferencia radica en el contenido de los elementos de este array, que son
referencias a un objeto de tipo string. Ojo, en cada elemento de este array no se encuentra un objeto string, sino una referencia a un objeto de tipo string, con lo cual es
necesario iniciar cada posición como se muestra a continuación:
ArraydeobjetosString[0] = new String(“Cadena1”);
ArraydeobjetosString[1] = new String(“Cadena2”);
ArraydeobjetosString[2] = new String(“Cadena3”);
26