PDF de programación - Estructuras básicas de datos en el lenguaje Java

fundamentos de programación
(unidad 4) programación estructurada en Java





Para ver una copia completa de la licencia, acudir a la
dirección http://creativecommons.org/licenses/by-nc-sa/2.5/es/legalcode.es



(3)



(5)

estructuras básicas
de datos en Java

esquema de la unidad

(5.1) arrays

(5.2) clase String

_________________________________________________________ 5

(5.1.1) introducción .............................................................................................................................. 5
(5.1.2) unidimensionales ................................................................................................................... 6
(5.1.3) arrays multidimensionales ................................................................................................. 11
(5.1.4) longitud de un array .......................................................................................................... 12
(5.1.5) la clase Arrays ....................................................................................................................... 12
(5.1.6) el método System.arraysCopy ........................................................................................ 14
____________________________________________________ 14

(5.2.1) introducción. declarar e iniciar textos ........................................................................... 14
(5.2.2) comparación entre objetos String ................................................................................. 15
(5.2.3) String.valueOf ...................................................................................................................... 16
(5.2.4) métodos de los objetos String ......................................................................................... 16
______________________________________________ 22

___________________________ 22


(5.3) arrays de Strings
(5.4) parámetros de la línea de comandos

(5.1) arrays

(5.1.1) introducción

Los tipos de datos que conocemos hasta ahora no permiten solucionar
problemas que requieren gestionar muchos datos a la vez. Por ejemplo,
imaginemos que deseamos leer las notas de una clase de 25 alumnos.
Desearemos por tanto almacenarlas y para ello, con lo que conocemos hasta
ahora, no habrá más remedio que declarar 25 variables.

Eso es tremendamente pesado de programar. Manejar esos datos
significaría estar continuamente manejando 25 variables. Por ello en casi
todos los lenguajes se pueden agrupar una serie de variables del mismo tipo en

(5)

fundamentos de programación
(unidad 5) estructuras básicas de datos en Java


una misma estructura que comúnmente se conoce como array1
. Esa estructura
permite referirnos a todos los elementos, pero también nos permite acceder
individualmente a cada elemento.

Los arrays son una colección de datos del mismo tipo al que se le pone un
nombre (por ejemplo nota). Para acceder a un dato individual de la colección
hay que utilizar su posición. La posición es un número entero, normalmente se
le llama índice (por ejemplo nota[4] es el nombre que recibe el cuarto
elemento de la sucesión de notas).

Hay que tener en cuenta que en los arrays el primer elemento tiene como
índice el número cero. El segundo el uno y así sucesivamente; es decir
nota[4] en realidad es el quinto elemento del array.

Esto (con algunos matices funciona igual en casi cualquier lenguaje). Sin
embargo en Java los arrays (como casi todo) son objetos, y aunque la
programación orientada a objetos de Java será abordada más adelante, ya
ahora conviene tenerlo en cuenta.

Por otro lado mientras en lenguajes como C los arrays son estructuras
estáticas (significa que su tamaño queda definido en cuanto se declara el
array), en Java son estructuras dinámicas (sí que es posible modificar su
tamaño en tiempo de ejecución).

Ilustración 4-1, Ejemplo de array de notas



(5.1.2) unidimensionales

Los arrays habituales son los llamados unidimensionales. Coinciden con la idea
comentada en el apartado anterior. Aglutinan datos del mismo tipo y un



1 Otros nombres habituales además de arrays son: listas, matrices, arreglos,… Estimo que
array es el más aceptado en la actualidad, los otros términos son más ambiguos.

(6)

1er curso de administración de sistemas informáticos
autor: Jorge Sánchez – www.jorgesanchez.net

índice encerrado entre corchetes nos permite acceder a cada elemento
individual.

La declaración de un array unidimensional se hace con esta sintaxis.

tipo nombre[];

Ejemplo:

double cuentas[]; //Declara un array que almacenará valores


// doubles



Declara un array de tipo double. Esta declaración indica para qué servirá el
array, pero no reserva espacio en la RAM al no saberse todavía el tamaño del
mismo. En este sentido hay una gran diferencia entre Java y la mayoría de
lenguajes clásicos. No es necesario conocer el tamaño del array en el
momento de la declaración. Simplemente se avisa de que aparecerá un futuro
array.

Tras la declaración del array, se tiene que iniciar. Eso lo realiza el
operador new, que es el que realmente crea el array indicando un tamaño.
Cuando se usa new es cuando se reserva el espacio necesario en memoria. Un
array no inicializado no se puede utilizar en el código.

Ejemplo de iniciación de un array:

int notas[]; //sería válido también int[] notas;
notas = new int[3]; //indica que el array constará de tres


//valores de tipo int



También se puede hacer ambas operaciones en la misma instrucción:

int notas[]=new int[3];

En el ejemplo anterior se crea un array de tres enteros (con los tipos básicos
se crea en memoria el array y se inicializan los valores, los números se inician
a 0).

Los valores del array se asignan utilizando el índice del mismo entre

corchetes:

notas[2]=8;

También se pueden asignar valores al array en la propia declaración:

int notas[] = {8, 7, 9};
int notas2[]= new int[] {8,7,9};//Equivalente a la anterior

Esto declara e inicializa un array de tres elementos. En el ejemplo lo que
significa es que notas[0] vale 8, notas[1] vale 7 y notas[2] vale 9.

(7)

fundamentos de programación
(unidad 5) estructuras básicas de datos en Java


En Java (como en otros lenguajes) el primer elemento de un array es el
cero. El primer elemento del array notas, es notas[0]. Se pueden declarar
arrays a cualquier tipo de datos (enteros, booleanos, doubles, ... e incluso
objetos como se verá más adelante).

La ventaja de usar arrays (volviendo al caso de las notas) es que gracias a
un simple bucle for se puede recorrer fácilmente todos los elementos de un
array:

//Calcular la media 18 notas
suma=0;
for (int i=0;i<=17;i++){

}
media=suma/18;

suma+=nota[i];

A un array se le puede inicializar las veces que haga falta:

int notas[]=new notas[16];
...
notas=new notas[25];

Pero hay que tener en cuenta que el segundo new hace que se pierda el
contenido anterior. De hecho elimina ese contenido.

En la perspectiva de Java, un array es una referencia a una serie de valores
que se almacenan en la memoria. El operador new en realidad lo que hace es
devolver una referencia a los valores a los que ha asignado el hueco en
memoria. Es decir el array es la manera de poder leer y escribir en esos
valores.

Veamos paso a paso estas instrucciones y su efecto en la memoria:

(8)

1er curso de administración de sistemas informáticos
autor: Jorge Sánchez – www.jorgesanchez.net

instrucción

int notas

;[]

notas=

new[ ]
5 ;

efecto

se crea la referencia notas

se crea un array de cinco números
enteros y nota hace referencia a ellos:

instrucción

notas=

new[ ]
8 ;

notas

0
0
0
0
0

se asignan valores en el array

notas

0
1
4
9
16

for(int i=0;i<5;i++){

nota[i]=i*i;
}

efecto

se crea un nuevo array de ocho enteros
notas le hace referencia, el anterior se
queda sin referencia

basura
digital

notas

0
1
4
9
16

0
0
0
0
0
0
0
0



Ilustración 4-2, efecto del uso del operador new en los arrays

La imagen anterior trata de explicar el funcionamiento del operador new (no
sólo para los arrays). Utilizar dos veces el operador new con la misma
referencia de array, provoca que haya valores que se quedan sin referencia. A
eso se le suele llamar basura digital, es espacio que se consume en la
memoria y que no se puede utilizar.

En Java un recolector de basura se encarga cada cierto tiempo de eliminar
la basura (a diferencia de lo que ocurre en lenguajes menos seguros como C).
Desde el código podemos forzar la recolección de basura mediante:

System.gc();

Aunque dicha instrucción no garantiza la recolección de basuras. Sólo se suele
utilizar cuando nuestro código genera basura más rápidamente de lo que el
recolector puede eliminar.

(9)

fundamentos de programación
(unidad 5) estructuras básicas de datos en Java



Un array se puede asignar a otro array (si son del mismo tipo):

int a[];
int b[]=new int[]{3,4,5,6,7,8};
a=b;

A diferencia de lo que podríamos intuir, lo que ocurre en el código anterior es
que tanto a como b hacen referencia al mismo array. Es decir el resultado
sería:

a

b

3
4
5
6
7
8

Esta asignación provoca que cualquier cambio en a también cambie el array b
(ya que, de hecho, es el mismo array). Ejemplo:

int a[]={3,3,3};
int b[];
b= a;
b[0]=8;
System.out.println(a[0]);//Escribirá el número 8

Finalmente, como detalle final a este tema, el operador de igualdad (==) se
puede utili