Vectores dinámicos

 "Movimiento es el paso de la potencia al acto... "

Ahora que ya vimos como crear un vector de forma estática, vamos a crear vectores que puedan modificar su tamaño en caso de que se requiera.

De esto se encargará la clase Vector, en la cuál se guardarán datos de tipo Object.

Su constructor más simple es como el de cualquier otra clase, en este constructor el vector tendrá un tamaño para diez elementos, en caso de que se rebase el tamaño, el vector automáticamente duplicará su tamaño para poder almacenar más valores.
Vector vec=new Vector( );

Si se desea tener un tamaño especifico y además incrementarlo a nuestro antojo, el segundo constructor recibirá el tamaño inicial como primer argumento y cuánto se incrementará como segundo argumento.

Vector vec=new Vector(30,1);//Se indica un vector de 30 elementos y un incremento de uno.

También es posible sólo asignarle el tamaño, si se rebasa su tamaño entonces este se duplicará.

Vector vec=new Vector(30);

Una vez que ya sabemos como construir el vector, nos podemos ayudar de sus funciones para insertar, eliminar u obtener datos.

Para insertarle datos podemos hacerlo de dos formas:
 La primera es asignarle el valor que vamos a guardar con el método add, se guardará en un índice consecutivo:

  vec.add("Valor a guardar");

La segunda es asignarle un índice y el valor:

  vec.add(0,"Valor a guardar");//se guardará en el primer índice.

Para eliminar basta con especificar en la función remove el índice del valor a eliminar:

 vec.remove (0 );//eliminará el valor del índice 0

Para obtener datos, disponemos de dos métodos:
El primero es con get( índice ):

  vec.get( 0 );//obtener el valor del índice 0

O también con el método elementAt( índice);

vec.elementAt(0 );//obtener el valor del índice 0

Aquí les dejo un ejemplo de como llevar a cabo estas funciones:

import java.util.*; //librería para usar la clase Vector y la clase Scanner

public class VectorDinamico

{

   Vector vec;//declaramos nuestro vector

    int tam=5;//tamaño del vector

    //Lo creamos en el constructor

    public VectorDinamico()

     {

         vec=new Vector(tam,1);//Vector de 5 elementos incrementando a 1

          llenar( );//método para llenar el vector

          mostrar( );//mostraremos los datos

         eliminar ( );//eliminamos un dato

         mostrar( );//mostramos de nuevo

      }

   public void llenar( )

   {

        for(int i=0;i  < tam;i++)

         { 

                Scanner sc=new Scanner(System.in);

               System.out.println("Dame un valor para el índice: "+i );

                 vec.add( sc.next( ) );

          }//fin del ciclo

   } //fin del método llenar

  public void mostrar()
    {
       for(int i=0;i < tam;i++)
       {
          
           System.out.println("Valor del índice: "+i+" es: "+vec.get(i));
          
       }      
   }//fin del método

  public void eliminar()
   {
        int ind;//variable para almacenar el indice obtenido
           Scanner sc=new Scanner(System.in);
           System.out.println("Indice del valor a eliminar: ");
           ind=sc.nextInt();
          vec.remove(ind);
           vec.add(ind,0);//Le asignamos el valor de 0 al valor eliminado para que no genere errores
   }

   public static void main(String[ ]args)
   {
     new VectorDinamico( );  
   }   

}//fin de la clase

Les dejo el resultado ya que me lo recomendaron:

Esto es todo por el momento, espero les sirva. Saludos!

Vectores, arrays estáticos en Java (Llenar y mostrar)

"Hay que dar para recibir..."

Ahora que ya sabemos llenar un vector estático, ahora nos dispondremos a llenarlo, un vector se maneja mediante índices los cuales nos ayudan a guardar o localizar datos específicos dentro del vector, los índices se comienzan a contar a partir de la posición 0, así pues, si un vector tiene longitud de 5 sus índices serán: 0,1,2,3,4 ; para posicionarse en un índice, basta con colocar el nombre del vector y en los corchetes el índice a solicitar.

vec[ índice];

Por ejemplo...
   System.out.println("El valor de la segunda posición del vector es: "+vec[ 1 ]);
...Para pedir un valor de cierto índice del vector:

    System.out.println("Dame el valor de la segunda posición del vector");

       vec[ 1]=leer.nextInt( );//esta función la veremos aplicada más adelante...

Sería tedioso si quisieramos llenar un vector especificandole índice por índice, o incluso caeríamos en incertudumbre si le decimos al usuario que teclee el tamaño de la matriz; los algoritmos habituales  para los vectores incluyen un ciclo que permite el llenado automatizado para el vector, eliminando así los dos problemas anteriores.

En este ejemplo presentaremos cómo podemos llenar al vector mediante un ciclo, los datos serán ingresados por teclado.

//importaremos la clase que nos permite leer desde teclado. 

import java.util.Scanner;

class miVector

 {

     int vec[ ]; //vector de tipo entero

      final int TAM=10; //tamaño de nuestro vector

      public miVector( )//constructor donde creamos nuestro vector

         {

             vec=new int[ TAM ];

          }

      public void llenar( )

      {

          //Usaremos un ciclo for para permitir el llenado, los índices serán representados por la variable i y el límite es el tamaño del vector.

  for(int i=0;i < TAM;i++)

                  {

                            //creamos el objeto para leer

                          Scanner  scan=new Scanner(System.in);

                          System.out.println("Dame un valor para posición "+i);

                          vec[ i ]=scan.nextInt( );//En esta etapa se almacena el dato en el vector según el índice.

                          //la variable i incrementará y el índice del vector cambiará.

                  }//fin del ciclo for
       }//fin del método de llenado

  

  public void mostrar( )

  { 

      //nuevamente un ciclo for

              for(int i=0;i < TAM;i++)

                  {

                          System.out.println("Valor del vector en la posición "+i+ " =  vec ["+vec[ i ]+"] " );
                  }//fin del ciclo for
  }//fin del método mostrar

public static void main(String[]args)

 {

     miVector obj=new miVector( );

    obj.llenar( );

    obj.mostrar( );

 }

 }

Con esto quiero acabar lo que fue una serie de programación básica para programar en Java. Sin embargo aún falta mucho, poco a poco iré subiendo más cosas que ayudaran en la programación, pero ya sin un orden específico.
PD: Agrego un fragmento de la salida 

Saludos!

Vectores, arrays estáticos en Java (Creación)

"Todo cabe en un jarrito, sabiéndolo acomodar..."

Muchas veces nos encontramos con la necesidad de agrupar muchos elementos en uno solo, los arrays, vectores o matrices son aquellos que nos permiten realizar tales actos.

¿Qué son los vectores?
Los Vectores no son más que un conjunto de elementos agrupados que tienen algo en común. Estos nos permiten agrupar en un sólo objeto más objetos, siempre y cuando pertenezcan al tipo del array creado.

Java nos permite dos formas de crear un vector: De forma estática y de forma dinámica.

He aquí primero de forma estática, ya que si se requiere algo dinámico es mejor usar "Listas Ligadas" (Que serán presentadas en otra entrada).


Creacion de un array:

tipo nombre_variable[ ]= new tipo[tamaño ];

Como verán es creado igual que cualquier otro objeto, se declara el tipo su nombre y se instancia, pero para que java entienda que es un vector, al nombre (antes o después) se colocan unos corchetes, y cuando se crea el objeto también se le asignan corchetes, dentro de los cuales se les asignará el tamaño, este tamaño va a ser el mismo durante su tiempo de ejecución, es por eso que se le dice estático.

Ejemplos:

En este ejemplo el vector se declara y posteriormente, en el constructor, se crea.

class miVector
{
  int vec[ ];//declaramos el objeto de tipo entero

  public miVector( )//Por lo regular los vectores se inicializan en el constructor
  {
    //creamos el objeto con un tamaño para 10 enteros, Aquí la variable no usa corchetes
     vec=new int[10];
   }
}

En este otro ejemplo se crea un vector y se construye en una sola línea

class miVector
{
public static void main(String[ ]args)
 {
   int vec[ ]=new vec[10];
 }
}

También podemos generar un vector con datos ya almacenados, los datos ya predefinidos se encontraran entre llaves y separados por comas:

Por ejemplo:

    int vector[ ]={0,1,2,3,4}// Un vector entero de 5 elementos

    String vec[ ]={"Armando","Beto","Carmen","Daniel"}// Vector cadena de 4 elementos

Por el momento mi intención era la de mostrar cómo se declara un arreglo, en la siguiente entrada mostraremos cómo posicionarse y cómo llenarlo.

Ciclos while y do-while

Continuando con los ciclos anteriores, vamos a presentar ahora los ciclos while y do-while, veremos pues su estructura y posteriormente los explicaremos:

Ciclo While:
while( condición)
{
//instrucciones...
}

Ciclo do-while:
do
{
//instrucciones...
}while (condicion)

Ahora bien, la principal diferencia radica en que en el ciclo while la condición precedida por la palabra reservada while estará al principio del ciclo, mientras que en el do-while estará al final, esto quiere decir que en primer ciclo las instrucciones se van a ejecutar sólo si la condición es cumplida; mientras que en el segundo las instrucciones se van a ejecutar al menos una vez antes de que se cumpla la condición, ahora veamos un ejemplo:

Ejemplo con ciclo while

Supongamos que declaramos anteriormente una variable llamada cond de tipo boolean.
boolean cond=false;
while(condicion==false)
{
System.out.println("La condición se repetirá hasta que cambie el valor de la condición");
//si cambiamos el valor de la condición, el ciclo terminará
cond=true;
}

Ejemplo con ciclo do-while

Vamos a declarar una variable de tipo short.
short cond=1;

do
{
System.out.println("Incrementando variable cond hasta que sea mayor a igual a 10");
cond++;

}while(cond<10);

Algunos puntos a recalcar en los ciclos es que hay que tener cuidado en donde pongamos el ";" ya que esto nos podría traer problemas, se los digo por experiencia y sé que ustedes también lo aprenderan por experiencia.

Ciclo for en Java

Dentro de los algoritmos de los programas, se requiere repetir algunas acciones hasta que se cumplan ciertas condiciones, es por eso que los ciclos nos ayudarán a satisfacer esas necesidades.

Java nos proporciona tres ciclos principales los cuáles son:
-Ciclo For
-Ciclo While
-Ciclo Do-While

Cada uno nos ayuda dependiendo de nuestras necesidades y los explicaremos a continuación.

Ciclo for
Este ciclo se basa en repetir ciertas acciones que pueden ser condicionadas principalmente por un índice que puede incrementarse o disminuírse.
Su estructura básica es:

for(contador;condicion;incremento/decremento)

{//Instrucciones... }

Como nos hemos dado cuenta, la instrucción consiste en escribir la palabra for, seguido de sus características encerradas entre paréntesis cada argumento es separado por punto y coma. El contador es el índice que va a ser inicializado en ese momento, este puede ser de tipo numérico o caracter, Java nos permite declarar la variable en ese momento; la condición nos indicará en que momento debe terminar nuestro ciclo y el incremento/decremento nos ayudara a manejar el índice según lo que necesitemos. Por ejemplo:

for(int i=0;i<10;i++)
System.out.println("Esto se repetirá diez veces");

ó por ejemplo:

for(int i=10;i>0;i--)
System.out.println("Valor del índice disminuyendo: "+i);

Aunque este ciclo es principalmente usado de esta forma, también podemos manejarlo de otras formas, por ejemplo un for sin índices y sin condición nos va a generar un ciclo infinito (hay que tener cuidado con esto...) :

for( ; ;)
System.out.println("Ciclo infinito");

En este otro ejemplo se utiliza de un break para poder romper el ciclo:

for( ; ; )
{System.out.println("Ciclo infinito cortado");break;}

Continuaremos con los ciclos While y Do-while...