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...

Rebanar listas y strings en Python 3

Hace un tiempo hable de esto un poco,de rebanar como le suelen decir a esto o hacer un split o tambien se le conoce como particionado ,el hecho es que me preguntaron sobre este tema porque no explique muy bien en una entrada pasada y bueno es un tema un poco raro ya que no es complicado pero lleva una sintaxis algo extraña,pero cuando nos familiaricemos no hay mas que ver bien lo que deseamos hacer:

Por ejemplo podemos voltear una cadena con una orden de particionado:

string = "Cadena de Texto :D"

print (string[::-1]) 

Y nos voltea la cadena :O

Bueno como ven se ve un poco rara la sintaxis,pero solo consta de tres partes:

[inicio:final:stride]

Y bueno consta con negativos y positivos:

negativo => hacia atrás

positivo => hacia adelante

positivo => 2 hacia adelante

negativo = -2 hacia atrás

1 => toda la lista o string, también cuenta con negativo

0 => Primer valor de la lista o string

He visto que al hablar de esto en algunos sitios,de la "competencia" de tiempo de tux solo se refieren al particionado como dos valores, el inicio y final,pero no,hay tres si contamos stride(espacio o paso) de aquí en adelante stride(y suena bien :P).Así que aprenderemos a usar estos tres declaradores de indices para hacer la llamada rebanada o particion,para en otro tutorial poder aprender a usar funciones anónimas

Bien, como he dicho en las particiones podemos usar números positivos o negativos (aquellos como -1), esto lo hace python para saber que es lo que queremos,pero al mismo tiempo al saber lo que queremos se dificulta el trabajo de indicarle a python lo que queremos hacer,por ejemplo queremos solo los 5,6 y 7 de una lista de 10 dígitos :O, fácil:

Pero primero a definir nuestra lista:

Podemos así:

numeros = [ 1,2,3,4,5,6,7,8,9,10 ] 

O también así

# Python 3 range(1,11) # Python 2

numeros = list(range(1,11)) # Usare este

Y imprimimos

print (numeros[4:7]) 

Script :


#!/usr/bin/env python3

numeros = list(range(1,11))

print (numeros[4:7])

Y el resultado es :

Cabe destacar que esto:

[inicio:final:stride]

inicio no se incluye en el conteo,por ejemplo si contamos desde 1 no se mostrara el uno si no el 2.

final si se incluye en el conteo,por ejemplo contamos desde 1 hasta 10 si se mostrara 10 y no 9.

stride es el conteo que usaremos,por ejemplo contar de dos en dos a cien:

#/usr/bin/env python3

dos_en_dos = list(range(1,101))

print (dos_en_dos[1:100:2]) # 1 no se cuenta iniciamos en 1 para que cuente desde 2,100 es el final(si se cuenta) y de dos en dos

En lo que hice al principio fue que voltee un string con un stride:

Ya que con ::

[::-1]

Nos estamos saltando los indices inicio y final y toma el valor de la cadena entera,y con el stride contamos hacia atrás como dice arriba, negativo es igual a hacia atrás,o de derecha a izquierda.

Esto mas que nada es para copiar valores,por ejemplo tenemos tres sistemas en una lista:

#!/usr/bin/env python3

sistemas = ["Gentoo","iOS","Arch"]

# Y solo queremos mostrar los tipo Linux

GyA = sistemas[0:3:2]

print ("Mis sistemas Linux son: " + GyA[0] + " y " + GyA[1])

Eso no fue magia y tampoco se fueron juntos porque los dos son linux :P

Como he dicho en otras entradas de python y de perl y hasta de bash,las listas,diccionarios,hashes arrays,vectores,y otras cosas necesitan indices, los cuales comienzan desde 0 y en el caso de particionado no es la diferencia,solo que es un poco mas complicado,pero bueno.

Esto mismo se puede usar en cadenas de texto,solo que los espacios también se cuentan,en las cadenas cada espacio sera un indice,y bueno eso es todo :D

Leer más...