feed twitter facebook LinkedIn facebook

Java » Añadir elementos al final de un ArrayList

octubre 22, 2014 por Víctor Cuervo Sin Comentarios Imprimir Imprimir

Ya hemos visto como insertar elementos en un ArrayList con el lenguaje Java, ahora vamos a ver como podemos añadir elementos al final de un ArrayList.

Para ello nos vamos a basar en tener elementos en una colección, con dicha colección podremos añadir elementos al final de un ArrayList. Así, lo primero será crear una colección con elementos. Por ejemplo un Vector:

  1. Vector<String> vector = new Vector<String>();
  2. vector.add("Irene");
  3. vector.add("María");

Ahora vamos a ver como sería nuestro ArrayList. Hemos creado ya un ArrayList al cual hemos insertado elementos para poder ver el efecto de añadir elementos al final de un ArrayList.

  1. ArrayList<String> al = new ArrayList<String>();
  2.  
  3. al.add("Victor");
  4. al.add("Luis");
  5. al.add("Elena");

Si mostramos el contenido por pantalla veremos que aparece:

{"Victor","Luis","Elena"}

Para añadir elementos al final de un ArrayList vamos a apoyarnos en el método .addAll. Dicho método recibe como parámetro la colección de elementos que hemos definido en el Vector y se ejecutará como método sobre nuestro ArrayList.

  1. al.addAll(vector);

Si ahora volvemos a recorrer nuestro ArrayList:

  1. for(int x=0;x<al.size();x++) {
  2. System.out.println(al.get(x));
  3. }

Lo que tenemos será el siguiente contenido:

{"Victor","Luis","Elena","Irene","María"}

Veremos que hemos añadido los elementos del Vector al final del ArrayList. El método .addAll nos ha servido para añadir elementos al final de un ArrayList de una forma muy sencilla.

Java » Insertar un elemento dentro de un ArrayList

octubre 20, 2014 por Víctor Cuervo Sin Comentarios Imprimir Imprimir

Un ArrayList se compone de una lista de elementos o nodos que están relacionados y los cuales podemos ir recorriendo. Y como representación de una lista podremos insertar un elemento dentro de un ArrayList.

Para poder insertar un elemento dentro de un ArrayList deberemos de saber que los elementos que hay dentro del ArrayList están numerados, siendo el 0 el índice del primer elemento.

Si creamos la siguiente ArrayList:

  1. ArrayList<String> al = new ArrayList<String>();
  2.  
  3. // Añadir elementos a un ArrayList
  4. al.add("Víctor");
  5. al.add("Luis");
  6. al.add("Elena");

Tendremos los siguientes índices:

[0] => "Víctor"
[1] => "Luis"
[2] => "Elena"

Para insertar un elemento dentro de un ArrayList vamos a ayudarnos del método .add. Este método es el mismo que utilizamos para insertar elementos en un ArrayList. Pero en este caso vamos a hacer uso del índice.

Y es que el índice será el valor que pasaremos como primer parámetro del método .add. Si se obvia dicho valor se añadirá el elemento al final de la lista.

  1. al.add(1,"Fernando");

El anterior código se utiliza insertar un elemento dentro de un ArrayList, en concreto en la posición 1. Quedándonos nuestra ArrayList de la siguiente forma:

[0] => "Víctor"
[1] => "Fernando"
[2] => "Luis"
[3] => "Elena"

Como podemos ver desplaza todos los elementos, incluido el elemento que se encontraba en dicha posición.

Si ahora queremos insertar un elemento al principio del ArrayList bastará con que indiquemos el índice 0.

  1. al.add(0,"Virginia");

Ahora nuestro ArrayList se quedará de la siguiente forma:

[0] => "Virginia"
[1] => "Víctor"
[2] => "Fernando"
[3] => "Luis"
[4] => "Elena"

Ya hemos visto como utilizar el método .add para insertar un elemento dentro de un ArrayList.

Java » Insertar elementos en un ArrayList

septiembre 30, 2014 por Víctor Cuervo Sin Comentarios Imprimir Imprimir

Una vez que hemos aprendido a crear un ArrayList vamos a ver como podemos insertar elementos en un ArrayList de Java.

Para aprender a insertar elementos en un ArrayList de Java tenemos que saber es que un ArrayList implementa una lista de contenido dinámico. Es decir, según vayamos insertando elementos en el ArrayList, el tamaño del mismo se irá incrementando dinámicamente.

Lo primero que haremos será crear el ArrayList:

  1. ArrayList<String> al = new ArrayList<String>();

En este caso hemos tipado a String el ArrayList, ya que todas las colecciones tienen que ir tipadas y los elementos que vamos a insertar en el ArrayList serán cadenas.

Para insertar elementos en un ArrayList de Java vamos a apoyarnos en el método .add().

  1. al.add(Elemento);

El parámetro que recibe el método .add() del ArrayList es el elemento que queramos insertar. Como en este caso son cadenas de texto, es decir, String, realizaremos las siguientes operaciones:

  1. al.add("Victor");
  2. al.add("Luis");
  3. al.add("Elena");

Por cada una de las líneas insertaremos un elemento en el ArrayList.

Si quieres ver que elementos has insertado en el ArrayList puedes listar el contenido de dicho ArrayList.

  1. for(int x=0;x<al.size();x++) {
  2. System.out.println(al.get(x));
  3. }

Java » Crear un ArrayList en Java

septiembre 28, 2014 por Víctor Cuervo Sin Comentarios Imprimir Imprimir

Un ArrayList es una colección de Java que implementa el interface List y que por lo tanto nos puede servir como implementador de listas.

Una de las cosas que tenemos que saber a la hora de crear un ArrayList en Java es que se crean con un tamaño por defecto, que podemos de forma dinámica ir añadiendo elementos y que en el caso de que el ArrayList supere su tamaño predefinido, automáticamente se le asignará un nuevo tamaño.

Para crear un ArrayList en Java tenemos tres formas:

Crear un ArrayList vacío

Para crear un ArrayList en Java vacío solo tendremos que instanciar la clase ArrayList mediante un constructor.

  1. ArrayList<String> al = new ArrayList<String>();

Recuerda que las colecciones hay que tiparlas. En este caso hemos tipado a String el ArrayList

Crear un ArrayList con un tamaño por defecto

Para crear un ArrayList en Java con un tamaño por defecto bastará con que indiquemos en el constructor el número de elementos que queremos que tenga en ArrayList.

  1. ArrayList<String> al = new ArrayList<String>(3);

En este código hemos indicado que el ArrayList tendrá capacidad para 3 elementos.

Crear un ArrayList desde otra colección

También podremos crear un ArrayList desde los datos que contenga una colección: un vector, un conjunto,...

Para ello lo primero será crear una colección con datos. En este caso vamos a crear un Vector.

  1. Vector<String> vector = new Vector<String>();
  2. vector.add("Irene");
  3. vector.add("María");

Y ahora vamos a crear el ArrayList con el contenido de este Vector. Para ello lo pasamos como parámetro del ArrayList.

  1. ArrayList<String> al = new ArrayList<String>(vector);

Ahora ya solo te queda elegir la forma en la que quieres crear un ArrayList en Java.

Java » Hola mundo con JavaFX

febrero 24, 2014 por ARIEL 4 Comentarios Imprimir Imprimir

En está ocasión vamos a usar la tecnología JavaFX para crear el ejemplo de Hola mundo con JavaFX, esta aplicación abrirá una ventana que muestra el clásico mensaje "Hola, mundo".

JavaFX es una tecnología que nos permite crear aplicaciones de escritorio RIA (Ritch Internet Applications)

Vamos a usar IntelliJ IDEA para crear el proyecto Hola Mundo con JavaFX.

Para ello elegimos New Project -> JavaFX Application:

IntelliJ

Lo primero será explicar los tres conceptos que tiene JavaFX:

  • El Escenario, que es representado por la clase Stage. El escenario es el representa al contenedor general de JavaFX.
  • La escena, es representada por la clase Scene y es la que tiene el contenido de lo que queremos representar. La escena, por lógica se monta sobre el escenario.
  • Los nodos de la escena, son los elementos que componen la escena. La clase superior que representa estos nodos es un Panel, en este caso vamos a utilizar un StackPane

Vamos a montar nuestro escenario del Hola Mundo con JavaFX, desde los nodos hasta la escena...

Crear un botón que nos salude

Lo primero que haremos será crear un botón que sea el que muestre el saludo. Para crear un botón escribiremos el siguiente código.

  1. Button boton = new Button("Saludar");
  2. boton.setVisible(true);
  3. boton.setOnAction(new EventHandler<ActionEvent>() {
  4. public void handle(ActionEvent event) {
  5. System.out.println("Hola Mundo!!!");
  6. }
  7. });

Como podemos ver es una simple clase Button, a la cual le hemos asociado un manejador mediante un EventHandler. Dicho EventHandler va a mostrar un saludo por consola.

El Panel Principal

Como hemos dicho hay que crear un nodo principal que será un Panel. En este caso es un StackPane.

  1. panel = new StackPane();

Sobre el Panel vamos a añadir el botón:

  1. panel.getChildren().add(boton);

Montando la escena

La escena es la que contiene a los nodos. Así que el montado de la Escena en JavaFX no deja de ser el añadirle los nodos.

  1. Scene escena = new Scene(panel, 250, 150, Color.BLACK);

Subir la escena, al escenario

Si ya tenemos la escena, solo nos queda subir la escena al escenario y mostrar el escenario

  1. primaryStage.setTitle("Iniciando con Java FX");
  2. primaryStage.setScene(escena);
  3. primaryStage.show();

Ahora veremos que el escenario es un atributo del método start, método básico en el desarrollo de aplicciones JavaFX.

Algunas cosas básicas más...

Antes de montar la aplicación Hola Mundo con JavaFX tiene que saber un par de cosas más sobre esta tecnología.

La primera es que la aplicación extiende de la clase Application

  1. public class Main extends Application {...}

Y lo segundo es, que el método principal es start, el cual recibe como parámetro el escenario, es decir la clase Stage.

  1. public class Main extends Application {
  2. @Override
  3. public void start(Stage primaryStage) throws Exception{
  4. ...
  5. }
  6. }

Espero que os haya sido útil la explicación de como realizar un Hola Mundo con JavaFX.

Java » Convertir una Lista en un Array

enero 31, 2014 por Víctor Cuervo 1 Comentario Imprimir Imprimir

Ya vimos en su momento como podíamos convertir, de una forma sencilla, un array en una lista en Java. En este caso vamos a ver la operación contraria que será convertir una lista en un array con Java.

Lo primero será definir una Lista. Para ello utilizamos el interface List implementado mediante una clase ArrayList. Hay que recordar que cuando utilicemos colecciones tenemos que indicar el tipo de colección que estamos utilizando. En nuestro caso vamos a crear una lista de cadenas o String.

  1. List<String> milista = new ArrayList<String>();

Para insertar cada uno de los elementos en la lista utilizamos el método .add().

  1. milista.add("Elemento 1");
  2. milista.add("Elemento 2");

Lo siguiente será crear el array sobre el que vamos volcar el contenido de la lista. A la hora de crear el array deberemos de asignarle el tamaño que tenga la lista. Para saber el tamaño de una lista en java utilizamos el método .size()

  1. String[] miarray = new String[milista.size()];

El interface List tiene un método .toArray() este es el método clave que nos va a convertir una lista en un array con Java. Así que simplemente invocamos el método indicando como parámetro el array sobre el que queremos volcar el contenido.

  1. miarray = milista.toArray(miarray);

Ahora, para comprobar que hemos realizado bien el proceso de convertir una lista en un array con Java vamos a recorrer el contenido del array y ver que es el mismo que insertamos en la lista.

  1. for(String s : miarray)
  2. System.out.println(s);

Y hasta aquí nuestro ejemplo de como convertir una lista en un array con Java. Esperamos que os haya ayudado.

Java » Números repetidos en un array Java

enero 30, 2014 por Víctor Cuervo Sin Comentarios Imprimir Imprimir

Los ejercicios de manipulación de arrays son muy recomendables para aprender la lógica de programación Java, así como sus estructuras. De esta forma tenemos algunos ejemplos como encontrar el primer número repetido, encontrar el número mayor y su posición,...

En este caso vamos a ver como podemos encontrar los números repetidos en un array Java. Es decir, la idea es partir de un primer array que contenga los números a buscar.

  1. int numeros[] = {1,2,3,4};

Y tener un segundo array que contenga la lista sobre la que buscamos.

  1. int lista[]= {2,4,5,2,4,4,4,3,4,2,3};

Una solución rápida sería realizar dos bucles for, el primero que recorra el primer array Java y el segundo que recorra el segundo array Java.

  1. for (int x=0;x<numeros.length;x++) {
  2. for (int y=0;y<lista.length;y++) {
  3. if (numeros[x]==lista[y])
  4. System.out.println("El número "+numeros[x]+" está repetido");
  5. }
  6. }

La verdad que este código funcionaría ya que al recorrer los dos arrays Java chequearíamos todos los números. Si bien vamos a intentar que sea un poco más óptimo en la búsqueda. Y es que la idea es en primer lugar ir recorriendo el array de números (igual que hacíamos antes).

  1. for (int x=0;x<numeros.length;x++) {
  2. ....
  3. }

Pero en la búsqueda sobre la lista vamos a utilizar un bucle while de Java. Este bucle contendrá dos condiciones, por un lado la del límite del array y por otro un flag que nos diga si hemos encontrado el número, ya que en este caso no hace falta buscar más y podremos parar la búsqueda.

El código sería el siguiente:

  1. for (int x=0;x<numeros.length;x++) {
  2. encontrado = false;
  3. iter = 0; // Iterador
  4.  
  5. while ((!encontrado) && (iter < lista.length)) {...}
  6. }

Vemos que hemos utilizado un flag encontrado que estará a "false" mientras no encuentre el número, será en este momento cuando cambiemos su valor para salir del bucle.

  1. for (int x=0;x<numeros.length;x++) {
  2. encontrado = false;
  3. iter = 0; // Iterador
  4.  
  5. while ((!encontrado) && (iter < lista.length)) {
  6. if (lista[iter] == numeros[x])
  7. encontrado = true;
  8. iter++;
  9. }
  10. }

Ya solo nos quedará preguntar por la variable encontrado para ver si se ha encontrado el número.

  1. for (int x=0;x<numeros.length;x++) {
  2. encontrado = false;
  3. iter = 0; // Iterador
  4.  
  5. while ((!encontrado) && (iter < lista.length)) {
  6. if (lista[iter] == numeros[x])
  7. encontrado = true;
  8. iter++;
  9. }
  10.  
  11. if (encontrado)
  12. System.out.println (numeros[x] + " es un número repetido. Encontrado en " + iter + " búsquedas");
  13. else
  14. System.out.println (numeros[x] + " no está en la lista. No encontrado en " + iter + " búsquedas");
  15. }

Adicionalmente vemos que en la variable iter tenemos el número de búsquedas que hemos realizado en el segundo array Java. Con esto ya tenemos resuelto como buscar números repetidos en un array Java.

Java » Calcular el sector circular en Java

septiembre 3, 2013 por ARIEL 1 Comentario Imprimir Imprimir

Sector circular, es la relación que existe entre el arco, el radio y el ángulo central de una circunferencia.

¿Qué necesito para calcular el sector circular en Java?

  1. conocer el valor de radio de la circunferencia
  2. la longitud del arco
  3. el valor del ángulo central

Para obtener el valor del ángulo central se emplea la siguiente fórmula trigonométrica:

ang_central= arco / radio

Para obtener el valor del sector circular se emplea esta otra fórmula trigonométrica:

sector_circular= (radio*radio) * ang_central / 2

Creamos una clase Java llamada "Sector.java".

  1. class Sector{
  2. private double radio;
  3. private double arco;
  4. //...
  5. }

Podemos definir un constructor y los métodos GET.

  1. class Sector{
  2. //...
  3.  
  4. public Sector(double radio,double arco){
  5. this.radio=radio;
  6. this.arco=arco;
  7. }
  8.  
  9. public double getRadio(){
  10. return radio;
  11. }
  12.  
  13. public double getArco(){
  14. return arco;
  15. }
  16.  
  17. }

Definimos los métodos para obtener el ángulo central y el sector circular:

  1. class Sector{
  2. //...
  3.  
  4. public double calculaAngulo(){
  5. return arco/radio;
  6. }
  7.  
  8. public double calculaSector(){
  9. return ((radio*radio)*calculaAngulo())/2;
  10. }
  11.  
  12. }

Lo que sigue es crear un método Java que sirva para mostrar los datos calculados:

  1. class Sector{
  2. //...
  3.  
  4. @Override
  5. public String toString(){
  6. return "Sector{radio: "+getRadio()+ ",arco:"+getArco()+", sector circular obtenido: "+calculaSector()+"}";
  7. }
  8.  
  9. //este es el método que muestra los datos calculados
  10. public void ver(){
  11. System.out.print(toString());
  12. }
  13.  
  14. }

La clase Java principal tiene el siguiente aspecto:

  1. public class Principal{
  2. public static void main(String[] args)throws Exception{
  3.  
  4. }
  5. }

Usaremos la clase Scanner para introducir los datos que se solicitan.

  1. import java.util.Scanner;
  2. public class Principal{
  3. public static void main(String[] args)throws Exception{
  4. Scanner in = new Scanner(System.in);
  5. }
  6. }

Instanciamos la clase Sector.

  1. import java.util.Scanner;
  2.  
  3. public class Ejemplos{
  4. public static void main(String[] args) {
  5. Scanner in=new Scanner(System.in);
  6. Sector sector=null;
  7. }
  8. }

Definimos dos variables: radio y longitud del arco

  1. //...
  2. Scanner in=new Scanner(System.in);
  3. Sector sector=null;
  4. double r=0.0, l=0.0;

Solicitamos los datos al usuario.

  1. System.out.print("Introduce el valor del radio: ");
  2. r=in.nextDouble();
  3. System.out.print("Introduce la longitud del arco: ");
  4. l=in.nextDouble();

Invocamos el constructor de la clase Sector y mostramos el resultado.

  1. sector=new Sector(r,l);
  2. sector.ver();
  3.  

Ejemplo. Si el valor del radio es de 5.5m y la longitud del arco es de 16.20m obtenemos un sector circular de 44.55m cuadrados:

Introduce el valor del radio: 5.5
Introduce la longitud del arco: 16.20
Sector{radio: 5.5,arco:16.2, sector circular obtenido: 44.55}

Java » Usar una Hashtable Java

agosto 2, 2013 por Francisco Meza 4 Comentarios Imprimir Imprimir

Una Hashtable Java es una estructura de datos que utiliza una función hash para identificar datos mediante una llave o clave (ej. Nombre de una persona). La función hash transforma una llave a un valor índice de un arreglo de elementos. En este caso a una índice de nuestra Hashtable Java.

Una Hashtable Java más específica del funcionamiento es la siguiente:

Identificador Dato
101 Harry
102 Potter
103 IRONMAN
104 IRONMAN
105 HALLO

Vea que el identificador será el que hace referencia a los datos en este caso solo será un nombre, para este caso haremos un pequeño ejemplo en java donde solo manejaremos una clase la cual tendrá las siguientes propiedades: un objeto de tipo hash con sus respectivos métodos, los elementos de la tabla y finalmente el main dentro de la misma clase

Lo primero será definir una variable contenedor para instanciar la clase Hashtable Java:

  1. Hashtable<String,String> contenedor=new Hashtable<String,String>();

Nos vamos a ayudar del método .put() para insertar elementos dentro de la Hashtable Java:

  1. contenedor.put("101", "Harry");
  2. contenedor.put("102", "Potter");
  3. contenedor.put("103", "IRONMAN");
  4. contenedor.put("104", "IRONMAN");
  5. contenedor.put("105", "HALLO");

El primer elemento será la clave y el segundo será el valor a almacenar.

Si queremos obtener un valor de la Hashtable Java tendremos que pasarle al método .get() la clave que queremos recuperar:

  1. System.out.println(contenedor.get("105"));
  2. System.out.println(contenedor.get("101"));

Mediante un Enumeration vamos a recorrer el contenido de nuestra Hashtable Java:

  1. Enumeration<String> enumeration = contenedor.elements();
  2. while (enumeration.hasMoreElements()) {
  3. System.out.println(""+"hashtable valores: " + enumeration.nextElement());
  4. }

Si queremos saber cuales son las claves de la Hashtable Java usamos el método .keys().

  1. Enumeration<String> llaves = contenedor.keys();
  2. while (llaves.hasMoreElements()) {
  3. System.out.println(""+"hashtable llaves: " + llaves.nextElement());
  4. }

También se puede obtener la enumeración de todas las claves mediante el uso del método .keys().

  1. System.out.println("Claves: " +contenedor.keys());

En unas pocas líneas de código hemos visto como poder usar una Hashtable Java.

Java » Calcular el volumen de una esfera en Java

junio 16, 2013 por ARIEL 1 Comentario Imprimir Imprimir

Para el ejemplo que nos permite calcular el volumen de una esfera en Java vamos a crear cuatro archivos:

  1. Una interface "Servicio"
  2. Una clase abstracta "Figura"
  3. Una clase hija "Esfera"
  4. Una clase principal "VolumenEsfera"

Y es que aprovecharemos y utilizaremos conceptos de herencia para resolver nuestro problema.

La fórmula para calcular el volumen de una espfera en Java es la siguiente

volumen=(4/3)*Math.PI*(r*r*r)

Donde r es el radio de la esfera.

Interface Servicio

Definimos un método dentro de la interface "Servicio"

  1. interface Servicio{
  2. public abstract void ver();
  3. }

La Clase Abstracta

La clase abstracta implementara el método de la interface, además posee un método que nos servirá para obtener el volumen de la esfera:

  1. abstract class Figura implements Servicio{
  2. private double radio;
  3. //este es el método que calcula el volumen de la esfera
  4. public abstract double volumen();
  5.  
  6. public Figura(){}
  7.  
  8. public Figura(double _radio){
  9. this.radio=_radio;
  10. }
  11.  
  12. public double getRadio(){
  13. return this.radio;
  14. }
  15. }

La Clase Concreta

Creamos la clase "Esfera" que hereda las propiedades y métodos de la clase abstracta:

  1. class Esfera extends Figura{
  2. double r;
  3.  
  4. public Esfera(){}
  5.  
  6. public Esfera(double _r){
  7. super(_r);
  8. r=_r;
  9. }
  10.  
  11. @Override
  12. public double volumen(){
  13. return ((4/3) * Math.PI*(r*r*r));
  14. }
  15.  
  16. @Override
  17. public void ver(){
  18. System.out.println(String.format("radio: %f , volumen esfera: %f",getRadio(),volumen()));
  19. }
  20. }

Como se puede notar la clase abstracta "Figura" no tiene la necesidad de hacer uso del método ver(), pero la clase hija "Esfera" si.

La clase principal tiene el siguiente aspecto:

  1. public class VolumenEsfera{
  2.  
  3. public static void main(String[] args) {
  4. Figura esfera=new Esfera(20);
  5. esfera.ver();
  6. }
  7. }

Espero que os haya sido de utilidad la explicación de como calcular el volumen de una esfera en Java y algún concepto que otro de las herencias.