Tutorial Java en Linux Basico 8

Estructuras dinámicas

En esta ocasión vamos a ver como declarar estructuras dinámicas en java,las llamadas arrays.

En ocasiones anteriores hemos visto los arreglos de una dimensión llamados vectores y de dos llamados matrices,a diferencia de los arreglos comunes que acabo de mencionar los arrays deben o son dinámicos en tamaño no estáticos,por ejemplo al definir un vector de 10 elementos de tipo int tenemos que hacer esto:

Integer  elementos[] = new Integer[10];

Pero si quisiéramos o mejor dicho si no supiéramos cuantos elementos va a tener el arreglo como le haríamos?

Aquí es donde entra ArrayList lo que seria como una simple lista en lenguajes como python o ruby.

Listas

Para usar ArrayList tenemos que importarlo:

import java.util.ArrayList;

Su constructor es este:

ArrayList elementos = new ArrayList();

De esta manera seria idéntico a un lenguaje de alto nivel(fácil) crear una lista,a lo que me refiero es que podemos crear una lista de distintos tipos de datos,int,string,float,etc a diferencia de lo que seria un vector de un solo tipo de dato:


Para añadir un elemento usamos el método add pasándole como parámetro el dato a usar,por ejemplo:

elementos.add("Hola Mundo"); // String

elementos.add(10); // int

elementos.add('a'); // char

Bien,aun asi cuando los llamemos se convertiran a un tipo envuelto:

int a Interger

char a Character // etc

Aun así no es muy recomendable usar este tipo de listas(con datos de muchos tipos),lo recomendable es usar un dato de un solo tipo ya que incluso el compilador muestra un error.

Para definir el tipo de datos que vamos a usar lo añadimos al lado del constructor entre etiquetas:

ArrayList arreglo = new ArrayList();

En donde tipo usamos un tipo envuelto,por ejemplo:

ArrayList arreglo = new ArrayList();

Primero vamos a ver los métodos de agregar y de obtener:

arreglo.add(10);

arreglo.add(120);

Ya hemos comentado el método add,para obtener un elemento del arreglo usamos el método get y le pasamos como parámetro el índice(comienza a contar desde 0) del elemento:

arreglo.get(10);

Si queremos ver el tamaño de un arreglo usamos el método size que nos devuelve un int,por ejemplo para recorrer los elementos de un array:

for (int i = 0;i < arreglo.size();i++)
    System.out.println(arreglo.get(i));

Antes de ver las otras funciones podemos ver que añadir tiene otra función,la cual es diferente,mientras el add normal "apila" los datos uno sobre otro,este otro add puede añadir un dato en cierta posición:

arreglo.add(posición,elemento);

Eso seria como un remplazar.

Bien ahora vamos a ver las formas de iterar los elementos de un array,forma uno:

Esta ya la vimos:

for (int i = 0;i < arreglo.size();i++)
    System.out.println(arreglo.get(i));

Forma dos:

Con un bucle foreach,donde Integer es el tipo de Objeto.

for (Integer x: arreglo) {
    System.out.println(x);
}

Forma tres con un Iterator,donde Integer no es el tipo de objeto.

import java.util.Iterator;

Iterator i = arreglo.iterator();

while(i.hasNext()) {
    System.out.println(i.next());
}

Bien que mas podemos hacer?

Tenemos mas funciones:

arreglo.clear(); // Limpia el array(lo resetea)

arreglo.contains(elemento); // Devuelve true si existe el elemento en el array

arreglo.remove(indice); // elimina un elemento basado en el índice

arreglo.remove(elemento); // elimina un elemento basado en el elemento

arreglo.toArray(); // Devuelve un array (Object[])

arreglo.indexOf(elemento); // Devuelve el índice del elemento contando desde la izquierda

arreglo.lastIndexOf(elemento); // Devuelve el índice del elemento contando desde la derecha


Hashes

Ahora vamos a ver como usar los arreglos asociativos o has tables,los cuales se usan igual que las listas solo que se usan con clave valor en vez de índice valor:

Para definir un Hashtable,primero lo importamos:

import java.util.Hashtable;

Ahora usamos este constructor:

Hashtable hash;

Los dos objetos son los que usaremos para clave y valor,se recomienda usar String para clave,por ejemplo:

Hashtable hash = new Hashtable();

Ahora vamos a ver como añadir elementos:

Usamos:

hash.put(clave,valor);

Por ejemplo usando el hash de arriba:

hash.put("uno",1);
hash.put("diez",10);
Ahora tenemos dos elementos en el hash,como los recuperamos?

hash.get(clave);

Por ejemplo:

hash.get("uno"); // devuelve 1

Tenemos funciones similares al de ArrayList:

hash.clear(); // Resetea el hash

hash.containsKey(clave); // Devuelve true si contiene la clave

hash.containsValue(valor); // Devuelve true si contiene el valor

hash.isEmpty(); // Devuelve true si esta vacio

hash.remove(clave); // Quita el objeto basado en clave

Como iteramos?

Aquí es un poco mas complicado ya que no podemos usar índices,pero aun así tenemos algunas opciones:

La primera opciones es usando Collection ,primero importamos:

import java.util.Collection;

Ahora creamos un objeto Collection,esta nos devolverá los valores:

Collection  col = hash.values(); // En donde Integer es el tipo de objeto de los valores
Luego creamos un Iterator,como con ArrayList y iteramos:

Iterator i = col.iterator();
while(i.hasNext()) {
  System.out.println(i.next());
}

Forma 2:

Esta otra forma es mas sutil ya que podremos usar las llaves y los valores,es usando Enumeration:

import java.util.Enumeration;

Enumeration en = hash.keys(); // En donde String es el tipo de Objeto de las claves

Bien ahora solo iteramos:

while(en.hasMoreElements()) {
      String key = en.nextElement();
      System.out.printf("Clave : %s Valor : %s\n",key,hash.get(key));
}

Eso es todo :D

Leer más...

Tutorial perl desde Unix variables hash

Vamos a ver otro tipo de variable en nuestro lenguaje que estamos viendo estos días,perl mi lenguaje interpretado favorito,en este caso veremos nos concentraremos en los hashes ya que como he dicho exsiten ditintos tipos de variables en Perl.


Que son los hashes?

Los hashes o también llamados hash como se describe %hash son variables de arreglo asociativo,esto quiere decir que asocia los valores que se encuentren dentro del hash con un valor y salida y retorna la salida

Si han visto los ejemplos de programas que he escrito en perl abran visto esto:

valor => salida

Pues asi es como se define un has

my %hash (

'valor' => 'salida'

) ;

Como pueden ver es una variable muy propia de perl que no es muy vista en otros lenguajes de programación

Y se llama de esta forma

my $variable = $hash{'valor'};

Ahora vamos a ver un ejemplo de script para que entiendan un poco mejor:


#!/usr/bin/env perl 

use strict;
use warnings;
use utf8;

# (Los sistemas que uso yo)

my %sistemas = (
'Ubuntu' => 'Linux',
'iOS' => 'Darwin',
'FreeBSD' => 'FreeBSD'
);

my $OSmobile = $sistemas{'iOS'};
my $OSdesktop = $sistemas{'FreeBSD'};
my $OSnetbook = $sistemas{'Ubuntu'};

print "\nLos nucleos de los sistemas operativos que uso son $OSmobile, $OSdesktop y $OSnetbook\n\n"


Usando While

Si queremos recorrer todos los valores de nuestro %hash con el sentido (valor,salida) para poder ver ambos al mismo tiempo podemos usar each que nos hace posible hacer esto.

Veamos un ejemplo



#!/usr/bin/env perl 

#===============================================

use strict;
use warnings;
use utf8;

my %sistemas = (
'iOS' => 'Darwin',
'Ubuntu' => 'Linux',
'FreeBSD' => 'FreeBSD',
'Gentoo' => 'Linux',
);

while ( my ($sitem, $nucleo) = each(%sistemas)) {
   print "Sistema: " . $sitem . " Nucleo: " . $nucleo . "\n";
    print "Basado en la salida del comando uname de Unix\n"

};

Y obtendrán esta salida:

Saber cuantos elementos tenemos en un hash


Como saber cuantos hash tengo:

Para eso se usa el comando keys con la sintaxis

.keys(%hash).

Dentro de un bucle

Veamos un ejemplo:


#!/usr/bin/env perl 

#===============================================

use strict;
use warnings;
use utf8;

my %sistemas = (
'iOS' => 'Darwin',
'Ubuntu' => 'Linux',
'FreeBSD' => 'FreeBSD',
'Gentoo' => 'Linux',
);


 print "Tamaño del hash:  " . keys( %sistemas ) . "\n";


Y devolverá cuantos valores hay en el %hash

Usando for

De igual manera que con while podemos recorrer nuestro hash usando el bucle for,la sintaxis es un poco distinta pero si nos damos cuenta se obtiene el mismo resultado

Ejemplo:


#!/usr/bin/env perl 

#===============================================

use strict;
use warnings;
use utf8;

my %sistemas = (
'iOS' => 'Darwin',
'Ubuntu' => 'Linux',
'FreeBSD' => 'FreeBSD',
      );

for my $key ( keys %sistemas ) {
my $nucleo = $sistemas{$key};
print "Sistema $key => Nucleo $nucleo\n"; 
};


Y se obtiene un resultado similar con for o mejor dicho keys que al usar while o mejor dicho each

Borrar elementos del hash

Al igual que agregar podemos borrar elementos que estén en nuestro hash,en esta ocasión borrar:

Para ello solo se usa el comando delete con la sintaxis:

delete( $hash{'elemento'});

Veamos un ejemplo:

#!/usr/bin/env perl 

#===============================================

use strict;
use warnings;
use utf8;

my %sistemas = (
'iOS' => 'Darwin',
'Ubuntu' => 'Linux',
'FreeBSD' => 'FreeBSD',
);

print "Elementos en el hash:  " . keys( %sistemas ) . "\n";

for my $key ( keys %sistemas ) {
my $nucleo = $sistemas{$key};
print "Sistema $key => Nucleo $nucleo\n"; 
};

print "Borrando iOS...\n";

delete( $sistemas{'iOS'});

print "Ahora hay :  " . keys( %sistemas ) . " elementos en el hash\n";

Como pueden ver no es muy difícil el manejo de %hash en perl :D

Agregar elementos al hash

Al igual que borrar podemos agregar elementos que estén en nuestro hash,en esta ahora agreagar:

Solo basta usar esta sintaxis:

$hash{'valor'} = 'salida';

Que seria como poner adentro del hash

'valor' => 'salida'

Veamos un ejemplo

Agregue dos subrutinas y el comando sleep para que se vea mas amigable y no tenga que repetir los comandos,pero aquí a lo que tienen que darle atención es a lo que esta de rojo:

#!/usr/bin/env perl 

#===============================================

use strict;

use warnings;

use utf8;

my %sistemas = (

'iOS' => 'Darwin',

'Ubuntu' => 'Linux',

'FreeBSD' => 'FreeBSD',

);

cargar();

visor();

sleep 1;

print "Agregando un nuevo sistema..\n";

sleep 2;

$sistemas{'Debian'} = 'Linux';

cargar();

visor();

sub visor {

for my $key ( keys %sistemas ) {

my $nucleo = $sistemas{$key};

print "Sistema $key => Nucleo $nucleo\n"; 

};

}

sub cargar {

print "Ahora hay :  " . keys( %sistemas ) . " elementos en el hash\n";

sleep 1;

print "Cargando...\n";

sleep 2;

}

Así de fácil y eficiente puede ser hash,hay muchas cosas mas que se pueden hacer con %hash pero yo solo quiero poner en la mesa lo mas básico ya que no he enseñado rutinas,abrir archivos,bucles,modulos,etc.

Espero que te sirva de algo este pequeño tutorial en el mundo de la programación Perl y claro desde Unix.

Leer más...