Fecha y hora actual: Jueves 17 Ene 2019 04:11
Índice del Foro

Foros de programación informática, diseño gráfico y Web

En esta comunidad intentaremos dar soporte de programación a todos los niveles, desde principiantes a profesionales de la informática, desarrollo de programas, programación web y mucho más.

Curso VB .NET - Tema 1.34 - Arrays, Java

Responder al Tema

Índice del Foro > Visual Basic .NET > Curso VB .NET - Tema 1.34 - Arrays, Java

Autor Mensaje
Tesis
Administrador


Registrado: 04 Mar 2007
Mensajes: 3200
Ubicación: Valencia - España

Mensaje Publicado: Viernes 23 Oct 2009 10:46

Título del mensaje: Curso VB .NET - Tema 1.34 - Arrays, Java

Responder citando

Curso de programación en .NET - Tema 1.34 - Arrays, Java


1. Arrays, Java.
1.1 Objetivos del tema.

Hecha la introducción a los arrays en el tema anterior, toca ahora su visión desde Java, las distintas acciones que se pueden llevar a cabo con ellos y su utilización.

1.2 Introducción.
Los arrays, también se pueden conocer como vectores, cuando son de una sola dimensión y como matrices cuando son de más de una dimensión.



El ejemplo superior es un vector de 7 elementos, un array de una dimensión.
En este otro ejemplo, es una matriz de dos dimensiones, 3 x 3, un array de dos dimensiones.



Hasta ahora en las estructuras de datos hemos visto que utilizamos variables para almacenar cada uno de los datos que se utilizan en un programa.

Pero en algunas ocasiones, en un programa es necesario guardar muchos datos que en su conjunto pueden tener el mismo nombre, por ejemplo podríamos guardar el nombre de un mes, y podríamos llamar a la variable NombreMes, pero también tenemos que tener presente que para asignarle el nombre, tendríamos que hacer antes un sin fin de sentencias condicionales hasta localizar la que coincida el nombre del mes con el de la fecha.

Código:
if (mes == 1)
{
   nombremes="Enero";
} else if (mes == 2)
{
   nombremes="Febrero";
}
// .../...


o bien
Código:
switch (mes)
{
   case 1: nombremes = "Enero"; break;
   case 2: nombremes = "Febrero"; break;
   case 3: nombremes = "Marzo"; break;
   // .../...
}


Por supuesto es válido, porque funciona, pero existe una alternativa mucho más cómoda a la solución anterior, y es crear un array de doce elementos en el que almacenamos el nombre de todos los meses y luego para hacer referencia al que nos interesa utilizamos la variable del ejemplo anterior como índice, y quedaría algo parecido a lo siguiente.
Código:
String NomMeses[] = {"Enero","Febrero","Marzo","Abril","Mayo"};
int mes = 1 ;
System.out.println(NomMeses[mes]);


Y si probamos éste ejemplo, veremos como el resultado es que el mes es Febrero, sí, porque la primera posición del array es cero y es el mes de Enero, y al índice que es la variable "mes", le hemos dado el valor uno, que es la posición del mes de "Febrero".

En Java, en realidad los elementos de un vector, o matriz, o array, se tratan como elementos de una clase predefinida.
Conclusiones,

  • Una variable --> un dato
  • Un array --> muchos datos bajo un mismo nombre.
  • Una variable --> no lleva índice
  • Un array --> tiene un índice para distinguir, o separar cada uno de los datos que contiene.
  • Un vector --> un índice, una dimensión.
  • Una matriz --> un índice para cada una de sus dimensiones.
  • Primer elemento de un array --> su dirección, su índice, es el cero.


Los arrays son direccionables, no hay que buscar un elemento para utilizarlo, si es que conoces su dirección, por el contrario, en según que acciones son mucho más lentos que las listas.

Las listas no son direccionables, para utilizar un elemento hay que llegar a él, hay que buscarlo.
Las listas son unas estructuras dinámicas en cuanto a su tamaño, los arrays por principio no, aunque en muchos lenguajes se dispone de instrucciones para cambiar su tamaño en tiempo de ejecución.

En cuanto a la discrepancia entre listas o arrays, es una historia absurda, lo adecuado es tener claro el funcionamiento de ambas estructuras y utilizarlas cada una en el momento adecuado, pero para ello hay que tener un criterio abierto, o no hay que cerrarse en banda, igual que con los lenguajes de programación.

Pero si que hay que tener claro que no tiene sentido implementar una lista con un array.

1.3 Creación.
Dos sintaxis para crear un array.
Código:
string NomMeses[] = {"Enero","Febrero","Marzo","Abril","Mayo"};


En la primera podemos observar que no se utiliza new, en la siguiente sí.
Código:
int v[] = new int[10];


El vector "V" quedará inicializado a cero.
El ejemplo que sigue crea la matriz de la imagen anterior.
Código:
int [] [] m = new int[3] [3];


En el ejemplo que sigue cargamos la matriz además de crearla.
Código:
int [] [] m = {
{1, 2, 3},
{4, 5, 6},
};


La matriz es de dos filas y tres columnas.
Siempre no es posible crear y cargar una matriz o un vector, pero hay veces en lo que eso es necesario y ésta sintaxis es muy práctica.

Existe la posibilidad de crear una matriz de distinto número de filas por columnas.
Código:
int [] [] m = new int [3][]; // creación del número de filas
m[0] = new int[2]; // definición de columnas por filas, 2
m[1] = new int[8]; // definición de columnas por filas, 8
m[2] = new int[4]; // definición de columnas por filas, 4


Probar a recorrer la matriz resultante de esta sintaxis, y podrá comprobar como cada fila tiene distinto número de columnas.

1.4 Recorrido.
En el ejemplo que sigue, vemos como recorrer el contenido del vector v.
Código:
public class Main {
   public static void main(String[] args) {
      int x =0;
      int v[] = new int[10];
      while (x<v.length)
      {
         System.out.println(v[x]);
         x=x+1;
      }
   }
}


En el bucle se utiliza un bucle del tipo mientras, es indistinto, podría utilizarse un repite, pero si conviene hacer hincapié en que, como en todos los bucles, de la importancia de colocar e inicializar adecuadamente el contador que se utiliza para recorrer el vector, para ello probar el ejemplo alterando el orden de las instrucciones del bucle.

Visto como se recorre el vector, veamos como se hace con una matriz, o un array de dos dimensiones.
Como principio, hay que indicar que una matriz necesita para recorrerse tantos contadores como dimensiones tiene, es decir tres dimensiones, tres contadores.

En el ejemplo utilizamos una matriz de dos dimensiones.
Cargaremos la matriz con datos, usaremos el vector del ejemplo anterior para ello.
Código:
public class Main {
   public static void main(String[] args) {
      int y[] = {0,1,2,3,4,5,6,7,8,9};
      int x = 0;
      int y = 0;
      int z = 0;
      int [] [] m ;
      m = new int[2] [5];

      while (x < m.length) // filas
      {
         y = 0;
         while (y < m[x].length) // columnas
         {
            m[x] [y] = v[z];
            y = y + 1;
            z = z + 1;
         }
         System.out.println();
         x=x+1;
      }
   }
}


Ahora vemos como visualizarla, la estructura es la misma.
Código:
public class Main {
  public static void main(String[] args) {
    int x = 0;
    int y = 0;
    int [] [] m ;
    m = new int[2] [5];
   
    while (x < m.length) // filas
    {
       y = 0;
       while (y < m[x].length) // columnas
       {
          System.out.print(m[x] [y] + " -");
          y = y + 1;
       }
       System.out.println();
       x=x+1;
    }
  }
}


En principio ésta es una forma de recorrer la matriz sin colocar en las condiciones del bucle el número de filas o de columnas de la matriz, que suele ser el formato normal,
Código:
while (x < m.length)

para las filas,
Código:
while (y < m[x].length)

para las columnas.

De ésta forma el bucle se ejecutará correctamente siempre independientemente del número de elementos del array.

Evidentemente la sintaxis que sigue también es correcta.
Código:
while (y < 5)


En Java en función de la sintaxis utilizada en la creación, se puede crear una matriz de un número irregular de columnas por fila, la sintaxis
Código:
public class Main {
  public static void main(String[] args) {
    int x = 0;
    int y = 0;
    int [] [] m = new int [3][]; // creación
    m[0] = new int[2]; // definición de columnas por filas, 2
    m[1] = new int[3]; // definición de columnas por filas, 3
    m[2] = new int[4]; // definición de columnas por filas, 4
    // .. /..
    // .. /..
   
    while (x < m.length) // bucle de filas
    {
       y = 0;
       while (y < m[x].length) // bucle de columnas
       {
          System.out.print(m[x] [y] + " ---");
          y = y + 1;
       }
       System.out.println();
       x=x+1;
    }
  }
}


Con ésta sintaxis en la estructura del bucle, se puede recorrer la matriz de manera segura, independientemente del formato de la misma.
La salida del ejemplo sería la siguiente
Código:
1 - 23 - 4 - 56 – 7 – 8 – 9


En los ejemplos, por costumbre, se ha recorrido la matriz por filas, pero no hay nada que impida que se recorra por columnas.
Pero ya que Java es un lenguaje orientado a objetos, veámoslo con una clase.

El siguiente es un sencillo ejemplo de clase.
Muy mejorable, pero fácil de entender.
Código:
package tema_32
public class ClaseVector
{
public int w[];
private ClaseVector()
{
  // impedimos que se declare sin recibir el vector en el new.
}

public ClaseVector (int v[])
{
  w = v; // se obliga a recibir un vector en el new.
}

public void VerVector()
{
  int x=0;
  while (x < w.length)
  {
    System.out.println(w[x]);
    x++; // incremento
  }
}


En la clase se ha recibido el vector en la inicialización del objeto, por lo que no es necesario recibirlo como argumento a la hora de visualizarlo.
Pero se podía haber hecho lo siguiente.
Código:
public int w[];
public ClaseVector()
{
   // declaramos public en lugar de private
}


Pero lo lógico entonces sería anular ésta sobrecarga.
Código:
public ClaseVector (int v[])
{
   w = v;
}


Y entonces el método VerVector sería como sigue.
Código:
public void VerVector(int w[]) // recibe el vector.
{
   int x=0;
   while (x < w.length)
   {
      System.out.println(w[x]);
      x++;
   }
}


Obligamos a que nos envíen el vector en el método. Y todo esto se utiliza como sigue.
Código:
package tema_32
public class Main {
  public static void main(String[] args)
  {
    int v[] = {10,9,8,7,6,5,4,3,2,1};
    ClaseVector Objeto = new ClaseVector(v);
    Objeto.VerVector(); // no se envía
    Objeto.OrdenaVectorAscendente();
    Objeto.VerVector(); // no se envía
  }
}


O bien si elegimos la opción de no inicializar el objeto enviando el vector
Código:
package tema_32
public class Main {
  public static void main(String[] args)
  {
    int v[] = {10,9,8,7,6,5,4,3,2,1};
    ClaseVector Objeto = new ClaseVector();
    Objeto.VerVector(v); // se envía
  }
}


Esta es otra de las posibilidades para recorrer un vector.
Es un bucle del tipo For, pero en el que se incorpora la sintaxis del tipo "para cada elemento del objeto recorre todos sus elementos". Aquí en éste caso el elemento es del tipo entero y el objeto es un vector.
Código:
for (int elemento: v ) System.out.print (elemento);


Siendo el resultado el que se indica a continuación, se ha utilizado "print" en lugar de "println"
Código:
1 2 3 4 5 6 7 8 9 10


1.5 Operaciones.
La existencia de las estructuras de datos, arrays o listas, tiene como fin el resolver problemas a la hora de desarrollar programas, por lo tanto su misión es la de almacenar datos u objetos, y la de localizarlos o acceder a ellos posteriormente.
Por lo tanto un array tiene distintos tipos de operaciones.

La principal acceder a los datos. Hay que recalcar que un vector o matriz permiten el acceso a sus datos de manera inmediata, sin necesidad de realizar búsquedas, lo cual es muy práctico en muchas ocasiones.
Pero no siempre es posible estructurar los datos de forma que se pueda acceder cómodamente y en algunas ocasiones hay que realizar búsquedas.

En otros momentos los datos en un array, no pueden guardarse de forma adecuada, y es necesario realizar operaciones de clasificación para obtenerlos en la forma adecuada o que nos interesa para el programa.

1.5.1 Acceso.
El acceso, si los datos están adecuadamente utilizados, es directo sin necesidad de realizar una búsqueda.

En el siguiente ejemplo, no es necesario buscar un elemento,
Código:
string NomMeses[] = {"","Enero","Febrero","Marzo","Abril","Mayo", ...};


Sabemos que el mes de Enero es el número uno en el año, Febrero el dos, etc..
Por lo tanto podemos perfectamente, sin necesidad de buscar el dato, hacer lo siguiente.
Código:
System.out.println(NomMeses[mes]);


Siendo "mes" una variable que contiene el mes de la fecha con la que trabajamos. Pero como siempre eso no es posible, a veces hay que buscar la información.

1.5.2 Copia.
Una de las acciones posibles es la copia del contenido de un vector sobre otro.
Para ello en Java disponemos del método ArrayCopy, que lo realiza con comodidad.

La sintaxis de éste método es la siguiente
Código:
System.arraycopy(v, 0, nuevo, 0, v.length);


Donde
V es el Vector origen.
0 es la primera posición en el vector origen.
Nuevo es el vector destino.
0 es la primera posición en destino.
v.length es el número de elementos a copiar de origen a destino.

Para realizar la prueba crearemos un vector inicializado,
Código:
int v[] = {10,9,8,7,6,5,4,3,2,1};


y después otro de mayor tamaño para realizar la copia sobre el nuevo.
Código:
// para la copia del vector
int nuevo [] = new int[12];


El programa podría quedar como sigue:
Código:
package tema_32
public class Main {
  public static void main(String[] args)
  {
    int v[] = {10,9,8,7,6,5,4,3,2,1};
    // para la copia del vector
    int nuevo [] = new int[12];
   
    System.arraycopy(v, 0, nuevo, 0, v.length);
    ClaseVector Prueba = new ClaseVector(nuevo) ;
    Prueba.VerVector();
  }
}


El resultado de la ejecución es el que sigue:
Código:
compile:
run:
10
9
8
7
6
5
4
3
2
1
0
0


Podemos observar que las posiciones sobrantes están inicializadas a cero.
En el caso de copiar un número inferior de elementos de un vector, sobre otro que ya existe con datos, el resto de elementos del vector destino que no entran en las posiciones copiadas, permanecen inalterables en su valor.

1.5.3 Clasificación.
Con las búsquedas sucede lo mismo, hay distintos tipos de algoritmos, unos más eficientes y otros menos, y como siempre depende del momento y lo que hay que hacer.

Como ejemplo exponemos uno, el de la burbuja, el menos eficiente, pero el más fácil de recordar, a partir de ahí, a mejorar.
A la clase anterior le podemos añadir éste método, y podremos desde el main visualizar el vector ordenado.
Código:
public int[] OrdenaVectorAscendente() // no se recibe vector.
{
   int y;
   int fin = w.length; // número de elementos de w
   int aux ;

   while (fin > 0)
   {
      y = 0;
      // cada pasada se reduce en uno el
      // número de elementos a comprobar
      fin = fin -1;
      // el mayor, en cada pasada se lleva
      // al final del vector.
      while (y < fin)
      {
         // comprobar si es mayor que el siguiente
         if (w[y] > w[y + 1] )
         { // intercambio, cuando es mayor
            aux = w[y];
            w[y] = w[y + 1];
            w[y + 1] = aux;
         }
         y++; // incremento
      }
   }
   return w;
}


En función de cómo guste más la clase, el inicio del método puede ser como se ha visto o como sigue,
Código:
public int[] OrdenaVectorAscendente(int w[]) // se recibe el vector.


Todo depende de que método de inicialización se haya dejado. Y en el principal del programa queda
Código:
package tema_32
public class Main {
  public static void main(String[] args)
  {
    int v[] = {10,9,8,7,6,5,4,3,2,1};
   
    ClaseVector Objeto = new ClaseVector(v);
    Objeto.VerVector(); // no se envía
    Objeto.OrdenaVectorAscendente();
    Objeto.VerVector(); // no se envía
  }
}


Pero si hemos usado la otra opción ...
Código:
package tema_32
public class Main {
  public static void main(String[] args)
  {
    int v[] = {10,9,8,7,6,5,4,3,2,1};
   
    ClaseVector Objeto = new ClaseVector();
    Objeto.VerVector(v); // se envía
    v = Objeto.OrdenaVectorAscendente(v); // se envía
    Objeto.VerVector(v); // se envía
  }
}


Expliquemos ésta línea de programa.
Código:
v = Objeto.OrdenaVectorAscendente(v); // se envía


Cuando hemos anulado la declaración del objeto con el envío del vector, la clase no tiene el vector en su poder, por decirlo de alguna forma, por lo que si queremos visualizar el vector, se lo hemos de enviar, la clase solo sabe del vector que recibe, por que no tiene ninguno.
Por lo tanto el método de ordenación, al igual que el de visualización, debe recibir el vector.

¿Pero que sucede?, si lo ordena, lo lógico es que lo devuelva, si no, para que sirve, por eso de ahí viene el cambio sintáctico de la utilización del método.

La diferencia entre un sistema y el otro es
Primer ejemplo.
  • Se crea el vector.
  • Se crea el objeto y se le pasa el vector.
  • El vector está en el objeto, y en el programa principal.
  • Se visualiza, lo que hay en el objeto.
  • Se ordena, lo que hay en el objeto.

Segundo ejemplo.
  • Se crea el vector.
  • Se crea el objeto, pero no se le pasa nada.
  • El vector solo está en el programa principal.
  • Al usar el método VerVector hay que enviarle el vector que ha de visualizarse.
  • Al usarse el método OrdenaVectorAscendente, como no hay vector en el objeto hay que enviarlo.
  • Y además lo recibimos ordenado para otros usos posteriores, como es el visualizarlo ordenado.


Void o no void, that is the question..

1.5.4 Búsqueda.
La búsqueda no es más que la utilización de una estructura repetitiva para recorrer el array y localizar el contenido que buscamos.
Existen distintos tipos de búsquedas, unas más eficientes que otras, aplicar una u otra solo dependerá del volumen de datos a utilizar, y de las necesidades en tiempos de respuesta.

Casi siempre es necesario tener el vector ordenado, por cuestiones de eficiencia.
La búsqueda solo es necesaria cuando no es posible establecer una relación entre el dato y su posición como es el caso de los meses del año, los días de la semana, etc..

Hay una búsqueda muy lógica y sencilla, que es leer el vector hasta que se encuentra o hasta el final.
Código:
public int BuscarDato(int que)
{
  int x = 0;
  while (x < w.length)
  {
     if (w[x]== que)
     {
        return x; // localizado
     }
     x++; // incremento
  }
  return -1; // no se ha encontrado
}


Este es el método que se puede añadir a la clase anterior para realizar la búsqueda, si lo encuentra devuelve la posición y en caso contrario devuelve un valor negativo. Poco eficiente y mejorable, si se le envía el vector ordenado. Hay otras más eficientes, pero no es el fin de este tema.

El main para ésta opción sería el siguiente.
Código:
package tema_32
public class Main {
  public static void main(String[] args)
  {
    int v[] = {10,9,8,7,6,5,4,3,2,1};

    ClaseVector Objeto = new ClaseVector(v);
    Objeto.OrdenaVectorAscendente();
    Objeto.VerVector();
    int posic = Objeto.BuscarDato(24);

    if (posic < 0 )
    {
       System.out.println("no existe");
    }
    else
    {
       System.out.println("El dato está en la posición " + posic);
    }
  }
}


Esta instrucción es contradictoria en su sintaxis, pero es uno de esos temas de los lenguajes de programación, " + posic. ", debería dar un error de tipo, pues no se debe concatenar una cadena y un entero, pero el entorno lo admite y se ejecuta correctamente, pues bien, vale.

También hay que reconocer que es cómodo.
Código:
System.out.println("El dato está en la posición " + posic);


1.5.5 Invertir.
Otra de las posibles operaciones con un array, es la de invertir el contenido del mismo, ponerlo del revés.
Una de las posibilidades para hacerlo es la de crear un bucle con dos contadores uno ascendente y otro descendente, pero dado que en Java podemos utilizar una pila, podemos utilizarla como apoyo una estructura distinta para agilizar el proceso.



Para ello es necesario que nuestra clase importe
Código:
import java.util.Stack;


De esa forma podemos escribir el método siguiente en nuestra clase.
Código:
public void Invertir()
{
  int x;
  // definir la pila.
  Stack stack = new Stack();
  // volcado del vector a la pila
  x = 0;
  Pila

  while (x < w.length)
  {
     // Introdución del contenido en la pila
     stack.push( (Integer) w[x]);
     x++;
  }
 
  // recuperación del contenido de la pila sobre el vector.
  x = 0;
 
  while (!stack.isEmpty() )
  {
     // extracción de un elemento de la pila
     w[x] = (Integer) stack.pop();
     x++;
  }
}


El main para ésta opción sería el siguiente.
Código:
package tema_32
public class Main
{
  public static void main(String[] args)
  {
    int v[] = {10,9,8,7,6,5,4,3,2,1};
   
    ClaseVector Objeto = new ClaseVector(v);
    Objeto.VerVector();
    Objeto.Invertir();
    System.out.println("Invertido");
    Objeto.VerVector();
  }
}


Mediante un bucle, sin usar la pila, podría ser:
Código:
public void Invertir()
{
   int v[] = new int[10];
   int X;
   int Y;
   X = 0;
   Y = v.length -1;

   while (X < v.length)
   {
      v[Y] = w[X]; // los contadores son ascendente y descendente
      X=X+1; //sube
      Y=Y-1; //baja
   }
   w = v; // se cambian los valores al vector de la clase.
}


Y el principal sería:
Código:
package tema_32;
public class Main
{
   public static void main(String[] args)
   {
      int v[] = {10,9,8,7,6,5,4,3,2,1};
      
    System.out.println("Fin del bucle, inicio de la clase");
      ClaseVector Objeto = new ClaseVector(v);
      Objeto.VerVector();
      Objeto.Invertir();
      Objeto.VerVector();
   }
}


1.6 Ejercicios propuestos.
1. Crear un vector de 10 elementos numéricos enteros, cargarlo con datos y visualizar su contenido.
2. Crear un vector de 10 elementos alfanuméricos, cargarlo con datos y visualizar el contenido de los que están ocupando la posición par.
3. Crear una matriz de 3 x 3 numérica, cargar los datos y visualizarla dando la visión de matriz.
4. Crear una matriz de 3 x 3 numérica, cargar los datos, intercambiar los datos de la 1 fila con la tercera fila, y visualizarla dando la visión de matriz.
5. Tenemos un Vector V de cincuenta elementos, generar un vector P de cincuenta elementos de forma que:
Código:
P(1) = V(1)
P(2) = V(1)+V(2)
P(3) = V(1)+V(2)+V(3) .. / ..
P(50) = V(1) ...V(50)

6. Introducir diez números y luego visualizarlos en orden inverso, al de entrada.
7. Introducir veinte números entre uno y cincuenta, y luego indicar cuales de esos cincuenta son los que se han utilizado.
8. Introducir veinte números entre uno y diez e indicar luego cuales han sido usados y el numero de veces que se ha usado cada numero.
9. Introducir veinte números entre uno y diez e indicar luego cuales han sido usados, el numero de veces que se ha usado cada numero, y el que más y el que menos se ha utilizado.
10.Introducir una fecha en tres variables, numéricas, día, mes y año. A esa fecha hay que sumarle 90 días reales, y visualizar la fecha resultante en el formato dia_en_letra de mes_en_letra de 20XX.

1.7 Soluciones a los ejercicios propuestos.
Para la solución de los ejercicios se ha creado una clase en la que se admite que se pueda crear el vector fuera de la clase y la reciba como argumento, se pueda generar del número de elementos indicado, o en caso contrario se crea un vector por defecto de diez elementos.

Para facilitar la prueba se ha creado un método que genera valores de forma aleatoria.
Código:
package Tema_34;
public class ClaseVector
{
   int w[];
   public ClaseVector () // vector por defecto
   {
      int v[] = new int[10];
      w = v;
   }
   public ClaseVector (int Cuantos) // Vector un número determinado de elementos
   {
      int v[] = new int[Cuantos];
      w = v;
   }
   public ClaseVector (int v[]) // Vector generado en el programa
   {
      w = v;
   }
   public void Genera()
   {
      int x=0;
      while (x < w.length)
      {
         // Genera valores entre 1 y 10.
         w[x] = (int) Math.floor(Math.random()*(10-1)+1);
         x++;
      }
   }
}


1. Crear un vector de 10 elementos numéricos enteros, cargarlo con datos y visualizar su contenido.
Con la clase que ya tenemos podemos crear un método que visualice el contenido del array.
Código:
public void VerVector()
{
   int x=0;
   while (x < w.length)
   {
      System.out.println(w[x]);
      x++;
   }
}


Para su utilización en la resolución del ejercicio.
Código:
package Tema_34;
public class Main
{
   public static void main(String[] args)
   {
      {
         int v[] = {10,9,8,7,6,5,4,3,2,1};
         System.out.println("Ejercicio 1");
         ClaseVector Objeto = new ClaseVector(v);
         Objeto.VerVector();
      }
   }
}


En esta versión, el vector se genera en el programa, pero podríamos haber hecho
Código:
package Tema_34;
public class Main {
   public static void main(String[] args)
   {
      {
         int v[] = new int[10];
         System.out.println("Ejercicio 1");
         ClaseVector Objeto = new ClaseVector(v);
         Objeto.Genera();
         Objeto.VerVector();
      }
   }
}


O también
Código:
package Tema_34;
public class Main {
   public static void main(String[] args)
   {
      {
         System.out.println("Ejercicio 1");
         ClaseVector Objeto = new ClaseVector(10);
         Objeto.Genera();
         Objeto.VerVector();
      }
   }
}


En la que se envía a la clase el número de elementos del vector.

2. Crear un vector de 10 elementos numéricos, cargarlo con datos y visualizar el contenido de los que están ocupando la posición par.
Para la solución del ejercicio creamos un método que nos visualice cualquier posición que le pidamos en el argumento.
Código:
public void VisualizaPosicion(int PosicionMultiplo)
{
   int x = 0;
   while (x != w.length)
   {
      if (x % PosicionMultiplo == 0)
      {
         System.out.println("Posición " + x + " Contenido " + w[x]);
      }
      x = x + 1;
   }
}


Al hacer está pregunta, podemos visualizar cualquier posición múltiplo de un valor x, y si su valor es uno, visualiza todos los elementos del array.
Código:
package Tema_34;
public class Main {
   public static void main(String[] args)
   {
      {
         System.out.println("Ejercicio 2");
         ClaseVector Objeto = new ClaseVector(10);
         Objeto.Genera();
         Objeto.VerVector();
         Objeto.VisualizaPosicion(2);
      }
   }
}


3. Crear una matriz de 3 x 3 numérica, cargar los datos y visualizarla dando la visión de matriz.
Para resolver este ejercicio creamos un procedimiento exclusivo, no utilizamos la clase.
Código:
package Tema_34;
public class Main
{
   static void GeneraMatriz( int m[] [])
   {
      int x;
      int y;
      int Filas = m.length; // M.GetLength(0) ' M.GetUpperBound(0)
      int Columnas = m[0].length; // M.GetLength(1) ' M.GetUpperBound(1)
      System.out.println("Generar matriz");
      // generar la matriz
      x = 0;

      do
      {
         y = 0;
         do
            {
               m[x] [y] = (int) Math.floor(Math.random()*(30-1)+1);
               y = y + 1;
            } while ( y < Columnas);
               x = x + 1;
      } while (x < Filas);
   }

   static void VisualizaMatrizDetalle(int m[] [] )
   {
      int x = 0;
      int y = 0;
      int Filas = m.length;
      int Columnas = m[x].length;
      System.out.println("Visualizamos el contenido");
      
    while (x < m.length) // filas
      {
         y = 0;
         while (y < m[x].length) // columnas
         {
            System.out.print(m[x] [y] + " -" );
            y = y + 1;
         }
         System.out.println();
         x=x+1;
      }
   }
 
   public static void main(String[] args)
   {
      {
         int [] [] m = new int[3] [3];
         System.out.println("Ejercicio 3");
         GeneraMatriz(m);
         VisualizaMatrizDetalle(m);
      }
   }
}


4. Crear una matriz de 3 x 3 numérica, cargar los datos, intercambiar los datos de la 1 fila con la tercera fila, y visualizarla dando la visión de matriz.

Al código del ejercicio anterior le añadimos el siguiente procedimiento.
Código:
static void Intercambio(int m[] [], int f1 , int f2 )
{
   int y ;
   int Columnas = m[0].length;
   int aux;
   // Intercambio
   y = 0;
   do
   {
      aux = m[f2] [y];
      m[f2] [y] = m[f1] [y];
      m[f1] [y] = Aux;
      y = y + 1;
   } while(y < Columnas);
}


Y el programa principal quedaría:
Código:
public static void main(String[] args)
{
   {
      int [] [] m = new int[3] [4];
      System.out.println("Ejercicio 4");
      GeneraMatriz(m);
      VisualizaMatrizDetalle(m);
      Intercambio(m,1,2);
      VisualizaMatrizDetalle(m);
   }
}


5. Tenemos un Vector V de cincuenta elementos, generar un vector P de cincuenta elementos de forma que:
Código:
P(1) = V(1)
P(2) = V(1)+V(2)
P(3) = V(1)+V(2)+V(3) .. / ..
P(50) = V(1) ...V(50)


Escribimos un método que resuelva el ejercicio, lo llamamos quinto y lo añadimos a la clase que ya tenemos hecha.
Código:
public void Quinto( int P[])
{
   int X;
   X = 1;
   P[0] = w[0];
   
  while (X < w.length)
   {
      P[X] = P[X -1] + w[X];
      X = X + 1;
   }
   w = P;
}


Como cada elemento es la suma del anterior más el nuevo, empezamos en la posición uno, pero hay que :
Código:
P[0] = w[0];


Para disponer de anterior.
Código:
P[X] = P[X -1] + w[X];


Al final de la ejecución asignamos el nuevo vector al de la clase, así podemos utilizar los métodos ya escritos.
Código:
w = P;


El programa principal queda como sigue:
Código:
public static void main(String[] args)
{
   {
      int P[] = new int[5];
      System.out.println("Ejercicio 5");
      ClaseVector Objeto = new ClaseVector(5);
   
     Objeto.Genera();
      Objeto.VerVector();
      Objeto.Quinto(P);
      Objeto.VerVector();
   }
}


6. Introducir diez números y luego visualizarlos en orden inverso, al de entrada. A la clase anterior le podemos añadir el siguiente método.
Código:
public void VisualizaInverso()
{
   int x = w.length;
   while (x > 0)
   {
      x = x -1;
      System.out.println(w[x]);
   }
}


Y el programa principal sería algo así:
Código:
public static void main(String[] args)
{
   {
      int P[] = new int[5];
      System.out.println("Ejercicio 5");
      ClaseVector Objeto = new ClaseVector(5);

      Objeto.Genera();
      Objeto.VerVector();
      Objeto.VisualizaInverso();
   }
}


7. Introducir veinte números entre uno y cincuenta, y luego indicar cuales de esos cincuenta son los que se han utilizado.

Podemos resolver el ejercicio con este procedimiento.
El vector a utilizar es del tipo bolean, solo nos piden cuales han sido usados.
Código:
static void Septimo()
{
   InputStreamReader teclado = new InputStreamReader(System.in);
   BufferedReader buffer = new BufferedReader (teclado);
   boolean V[] = new boolean[50];
   System.out.println("Ejercicio 7");
   int x=0;
   int entero;

   try
   {
      x=0;
      // Captura de números
      while (x !=20)
      {
         entero = Integer.parseInt(buffer.readLine());
         // Control de número válido
         if ((entero > 0) & (entero <51))
         {
            V[entero] = true; // Guardar o marcar número utilizado
         }
         x++;
      }
      // Visualización de números utilizados
      x=0;
      while (x !=50)
      {
         // Control de los números utilizados
         if (V[x])
         {
            System.out.println("El número " + x + " ha sido utilizado.");
         }
         x++;
      }
   }
   catch (Exception e)
   {
      System.out.println("Error " + e.toString());
   }
}


Para el correcto funcionamiento del procedimiento hay que importar:
Código:
package Tema_34;
   import java.io.InputStreamReader;
   import java.io.BufferedReader;

Para la entrada de datos por teclado.

8. Introducir veinte números entre uno y diez e indicar luego cuales han sido usados y el numero de veces que se ha usado cada numero.
Este ejercicio es igual que el anterior, pero en lugar de visualizar cuales además pide cuantas veces, pero el cambio es mínimo, en lugar de marcar número usado, contamos las veces que cada número ha sido usado.

Por lo tanto el vector no podrá ser de tipo booleano, si no que tendrá que ser entero, al menos.
Código:
V[entero] = V[entero] + 1; // Contar cuantas veces se ha utilizado


Y después el que sea mayor que cero, es el que ha sido usado.
Código:
if (V[x] > 0)


Veamos el procedimiento completo.
Código:
static void Octavo()
{
   InputStreamReader teclado = new InputStreamReader(System.in);
   BufferedReader buffer = new BufferedReader (teclado);
   int V[] = new int[10];
   System.out.println("Ejercicio 8");
   int x=0;
   int entero;
   try
   {
      // Captura de números
      x=0;
      while (x !=20)
      {
         entero = Integer.parseInt(buffer.readLine());
         if ((entero > 0) & (entero <11))
         {
            V[entero] = V[entero] + 1; // Conteo
         }
         x++;
      }
      // Visualización de números utilizados
      x=0;
      while (x !=10)
      {
         // Control de los números utilizados
         if (V[x] > 0)
         {
            System.out.println("El número " + x + " ha sido utilizado " + V[x] + " veces.");
         }
         x++;
      }
   }
   catch (Exception e)
   {
      System.out.println("Error " + e.toString());
   }
}


Para el correcto funcionamiento del procedimiento hay que importar:
Código:
package Tema_34;
   import java.io.InputStreamReader;
   import java.io.BufferedReader;

Para la entrada de datos por teclado.

9. Introducir veinte números entre uno y diez e indicar luego cuales han sido usados, el numero de veces que se ha usado cada numero, y el que más y el que menos se ha utilizado.
La solución es la misma que antes, pero en el procedimiento hay que añadir la búsqueda del que más y el que menos ha sido usado.
Código:
static void Noveno()
{
   InputStreamReader teclado = new InputStreamReader(System.in);
   BufferedReader buffer = new BufferedReader (teclado);
   int V[] = new int[10];
   System.out.println("Ejercicio 8");
   int x=0;
   int entero;
   try
   {
      // Captura de datos
      x=0;
      while (x !=20)
      {
         entero = Integer.parseInt(buffer.readLine());
         // Control de número válido
         if ((entero > 0) & (entero <11))
         {
            V[entero] = V[entero] + 1; // Conteo
         }
         x++;
      }
      // Visualización de resultados
      x=0;
      int Mas = 0;
      int Menos = 1;
      while (x < V.length)
      {
         if ( V[x] > 0)
         {
            if (V[Mas] < V[x]) Mas = x;
            if (V[Menos] > V[x]) Menos = x;
            System.out.println("El número " + x + " ha sido utilizado " + V[x] + " veces.");
         }
         x++;
      }
      System.out.println("El número " + Menos + " ha sido el menos utilizado " + V[Menos]);
      System.out.println("El número " + Mas + " ha sido el más utilizado " + V[Mas]);
   }
   catch (Exception e)
   {
      System.out.println("Error " + e.toString());
   }
}


Para el correcto funcionamiento del procedimiento hay que importar:
Código:
package Tema_34;
   import java.io.InputStreamReader;
   import java.io.BufferedReader;

Para la entrada de datos por teclado.

10. Introducir una fecha en tres variables, numéricas, día, mes y año. A esa fecha hay que sumarle 90 días reales, y visualizar la fecha resultante en el formato día_en_letra de mes_en_letra de 20XX.
Código:
static void Decimo()
{
   InputStreamReader teclado = new InputStreamReader(System.in);
   BufferedReader buffer = new BufferedReader (teclado);
   int Dia = 0;
   int Mes = 0;
   int Year = 0 ;
   int NvoDia ;
   int Dias ;
   int Y ;
   // Creación y carga de vectores
   int M[] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
   String DiaLet[] = {"", "UNO", "DOS", "TRES", "CUATRO", "CINCO", "SEIS", "SIETE", "OCHO", "NUEVE", "DIEZ", "ONCE", "DOCE", "TRECE", "CATORCE", "QUINCE", "DIECISEIS", "DIECISIETE", "DIECIOCHO","DIECINUEVE","VEINTE","VEINTIUNO", "VEINTIDOS", "VEINTITRES", "VEINTICUATRO", "VEINTICINCO", "VEINTISEIS", "VEINTISIETE", "VEINTIOCHO", "VEINTINUEVE", "TREINTA", "TREINTA Y UNO"};
 
   String MesLet[] = {"", "ENERO", "FEBRERO", "MARZO", "ABRIL", "MAYO", "JUNIO", "JULIO", "AGOSTO", "SEPTIEMBRE", "OCTUBRE", "NOVIEMBRE", "DICIEMBRE"};
   System.out.println("Sumarle 90 días reales, y visualizar la fecha " + "en el formato día_en_letra de mes_en_letra de XXXX");
   // INTRODUCCION DE FECHA
   try
   {
      Dia = Integer.parseInt(buffer.readLine());
      Mes = Integer.parseInt(buffer.readLine());
      Year = Integer.parseInt(buffer.readLine());
   }
   catch (Exception e)
   {
      System.out.println("Error " + e.getMessage());
      System.out.println("Error " + e.toString());
   }

   // Fecha a días
   Y = 0;
   Dias = 0;
   if (Year % 4 == 0)
   {
      M[2] = 29;
   }
   else
   {
      M[2]= 28;
   }
   while (Y != Mes -1) // Los días del mes actual se suman al final
   {
      Y = Y + 1;
      Dias = Dias + M[Y];
   }
   Dias = Dias + Dia + 90; // Días + 90 + Días del mes actual.
   // Días a fecha
   Y = 0;
   NvoDia = 0;

   while (NvoDia + M[Y + 1] < Dias)
   {
      Y = Y + 1; // Contar los meses desde el principio
      NvoDia = NvoDia + M[Y];
      if (Y == 12) // Por el posible cambio de año
      {
         Y = 0;
         Year = Year + 1;
         if (Year % 4 == 0)
         {
            M[2] = 29;
         }
         else
         {
            M[2] = 28;
         }
      }
   }
  // Fecha final
  Dia = Dias - NvoDia;
  Mes = Y + 1;
  System.out.println("Nueva fecha " + DiaLet[Dia]+ " de " + MesLet[Mes] + " de " + Year);
}


Para el correcto funcionamiento del procedimiento hay que importar:
Código:
package Tema_34;
   import java.io.InputStreamReader;
   import java.io.BufferedReader;

Para la entrada de datos por teclado.


Autor del curso: casiopea


Normas del foro
Aprende a postear correctamente usando las etiquetas
Volver arriba
Ver perfil del usuario Enviar mensaje privado
Responder al Tema
Mostrar mensajes anteriores:   
Ir a:  
Todas las horas están en GMT + 2 Horas

Temas relacionados

Tema Autor Foros Respuestas Publicado
El foro no contiene ningún mensaje nuevo

Ayuda con TestNG Parametrico en java netbeans

baltigo Java 0 Sábado 30 Jun 2018 01:37 Ver último mensaje
El foro no contiene ningún mensaje nuevo

Publicar Aplicación web JAVA en tomcat

Irvin Java Web 1 Viernes 13 Oct 2017 17:54 Ver último mensaje
El foro no contiene ningún mensaje nuevo

Imagen referencial De creación de jtable en apl...

Jensel S.G Java 6 Miércoles 13 Sep 2017 20:06 Ver último mensaje
El tema está bloqueado: no pueden editarse ni agregar mensajes.

EMPLEO ANALISTA PROGRAMADOR/A BACK-END JAVA EE

GRUPOARESTORA Bolsa de trabajo 0 Viernes 23 Jun 2017 14:33 Ver último mensaje
El foro no contiene ningún mensaje nuevo

Curso de PHP-WordPress avanzado

wordpressadict PHP 1 Domingo 27 Nov 2016 19:59 Ver último mensaje
Panel de Control
No puede crear mensajes, No puede responder temas, No puede editar sus mensajes, No puede borrar sus mensajes, No puede votar en encuestas,