CAPITULO VIII

Lo que no me puedo olvidar de Vectores

·         Inicialización

·         Ingresar datos

·         Mostrar datos

·         Otros algoritmos

ü  Ordenación

ü  Búsqueda

1.      Inicialización

Int V[ ] = new int [n];

Objetc  O[ ] = new Objet [n];

Vector V2 = new Vector (5)

//Import java.util.Vector;

Int V3[ ]; //solo es una referencia, no es instancia.

2.      Ingresar datos

                                                    0          1          2           V

V[0] = 25;       

Constante

                                   0          1          2          3          4         

300

200

0

0

10

V2.add (300);             

V2.add (200);

V2.add (10,4);

            Método

            V1 [i] = 30

            Variable

// Por teclado?????

Buffered = Es una memoria auxiliar, almacenamiento temporal de un proceso

BufferedRead   Val=(new BufferedReader(new InputSheauReader(System.in)));

Int  num = Integer.ParseInt (val.readLine ());

                                                           Flujo de teclado

3.      Mostrar datos          

Public static void Mostrar V(Vector x){

                For (int i = 0; i < x.size (); i++)

Método

                System.out.printLn (“ [ ” + i + “]” = + x.get( i ));

4.       Ordenación

2

1

3

5

V

                               I              j

                               1             2             3             5

                               I                              j              j

                               1             2             3             5

                                               I              j              j

                               1             2             3             5

                                                               I              j

                               1             2             3             5

                                                                              I              j

Public void Ordenar (int V [] ){

                For (int i = 0 ; i < V.length ; i++){

                               For (int i = 0; j < V.length; j++){

                                               If (V [i] < V [j]){

                                                               Int aux = V[j];

                                                               V[i] = V [j];

                                                               V[j] = aux;

}

}

}

}          

Import java.util.Arrays;

                                Arrays.Sort (V);

                                Mostrar (V);

5.       Búsqueda

2

1

9

3

V
                                                                                                                             Lineal secuencial

Elem = 9

                Return (1);

                               0             1             2             3             4

2

3

7

10

25

V2

                                                                                                                  Ordenado BBinaria

                               Elem=10                     Return (3)

                Public static int Buscar (int V [], int elem){

                               Int pos = -1;

                               For (int i = 0; i < V.length ; i++){

                                               If ( V[i] == elem)

                                               Pos=i];

}

                        Return pos;

}

            Import java.util.Arrays;

            Arrays.BinarySearch (V.elem);

           

EJERCICIOS

public class vector {

   public static void ordenar(int V[]){     

    for( int i = 0; i < V.length; i ++ ){

            for( int j = 0; j < V.length; j ++ ){

                         if(V[ i ] < V[ j ]){

                         int aux = V[ i ];

                         V[ i ] = V[j];

                         V[ j ] = aux;

                         }else if(V[ i ] > V[ j ]){

                                     int aux = V[ i ];

                                      V[ i ] = aux;

                                     V[ j ] = V[j];

      }

    }

   }

 

    }

   public static void mostrar (int V[]){    

      for(int i=0; i<V.length; i++){

            System.out.println(" [ " + i + " ] =  " + V[i]);      

     }

}

    public static void main(String[] args) {      

       int vec[]={7,9,1,3,8,2};

       System.out.println("vector desordenado");

            mostrar(vec);

            System.out.println("vector ordenado: ");

            ordenar(vec);

            mostrar(vec);                         

    }

    }

CAPITULO VII

Vectores.- Son estructuras estática por preferencia, es una estructura de datos que contiene una colección de datos del mismo tipo

            V (3)   

0                      1                      2                                

Matrices.-

            M(2,3)

0                      1                      2

0

1

Cubo.- Es una zona de almacenamiento continuo, que contiene una serie de elementos del mismo tipo, los elementos de la matriz. Desde el punto de vista lógico una matriz se puede ver como un conjunto de elementos ordenados en fila (o filas y columnas si tuviera dos dimensiones).

1.      Ordenar el vector con el método completo de ordenación de su preferencia

public class vector {

   public static void ordenar(int V[]){     

    for( int i = 0; i < V.length; i ++ ){

    for( int j = 0; j < V.length; j ++ ){

     if(V[ i ] < V[ j ]){

      int aux = V[ i ];

       V[ i ] = V[j];

       V[ j ] = aux;

      }else if(V[ i ] > V[ j ]){

       int aux = V[ i ];

       V[ i ] = aux;

       V[ j ] = V[j];

      }

    }

   }

 

    }

   public static void mostrar (int V[]){    

      for(int i=0; i<V.length; i++){

            System.out.println(" [ " + i + " ] =  " + V[i]);      

     }

}

    public static void main(String[] args) {      

       int vec[]={7,9,1,3,8,2};

       System.out.println("vector desordenado");

            mostrar(vec);

            System.out.println("vector ordenado: ");

            ordenar(vec);

            mostrar(vec);                         

    }

    }

METODOS DE LAS CLASES VECTOR - ARRAYS

METODOS DE LAS CLASE

VECTOR

En una clase, cada método realiza una tarea relativamente autónoma. Este permite

Que los programadores puedan dividir un problema complejo en varias piezas más

Pequeñas y manejables. Una vez que el método se ha escrito y se ha probado

Correctamente, el programador ya no necesita preocuparse por su funcionamiento

Interno. Los usuarios simplemente utilizan el método y los argumentos adecuados para

Invocarlo siempre que se necesite su funcionalidad.

Cada método cuenta con:

·         Identificador de acceso. Al igual que las variables, los métodos pueden ser

public o private (existen otros identificadores de acceso que trataremos

más adelante en el curso). A los métodos private solamente se puede

acceder desde dentro de la clase. Por su parte, a los métodos public

puede acceder cualquiera, tanto desde dentro como desde fuera de la

clase.

·         Tipo devuelto. Un método puede devolver un valor al usuario. Puede

tratarse de un tipo de datos simple, como int o de otra clase. Un tipo

devuelto void indica que no se devolverá ningún valor.

·         Nombre. El nombre de un método debe comenzar con una letra, distingue

entre mayúsculas y minúsculas y no puede ser una palabra reservada de

Java. Una buena práctica es utilizar nombres descriptivos, por ejemplo,

setHeight.

·         Lista de argumentos. Los argumentos son campos de entrada par aun

método. Un parámetro puede ser un tipo de datos simple y otra clase.

En Java, los métodos DISTINTOS de la MISMA clase pueden tener el mismo nombre y

devolver el mismo tipo de datos, pero tener un conjunto de parámetros DISTINTO (este

conjunto de parámetros recibe el nombre de firma del método). Este hecho se conoce

como la “sobrecarga de métodos”. Se llamará al método correcto dependiendo del tipo

y del número de argumento(s).

Definir un método

Para poder invocar un método, primero es necesario definirlo. La definición del

método proporciona los detalles sobre el modo de realizar las tareas. Dado que cada

método es un fragmento de código autónomo, puede definir sus propias variables y

métodos.

Utilizando nuestra clase Box, vamos a definir 7 métodos:

public class Box

{

private double width;

private double height;

private double length;

// Método para calcular el volumen de una caja

public double volume()

{

}

return width*height*length;

// Método para establecer el valor del ancho de la caja

public void setWidth(double w) {

width = w;

}

// Método para establecer el valor del alto de altura de la caja

public void setHeight(double h){

height = h;

}

// Método para establecer el valor de la longitud de la caja

public void setLength(double l){

length = l;

}

// Método para obtener el valor del ancho de la caja

public double getWidth(){

return width;

}

// Método para obtener el valor de la altura de la caja

public double getHeight(){

return height;

}

// Método para obtener el valor de la longitud de la caja

public double getLength(){

return length;

}

}

Utilizando los métodos de la clase Box:

Para llamar a los métodos que hemos definido en la clase Box, utilizamos un .

(operador de punto). Por ejemplo:

public class Example{

public static void main (String args[]) {

Box myFirstBox = new Box(); // creación de la caja

myFirstBox.setWidth(7.5);

myFirstBox.setHeight(6.97);

myFirstBox.setLength(2);

System.out.println("El volumen es " + myFirstBox.volume());

}

}

Arrays

Un array es un conjunto de valores del mismo tipo. Para hacer referencia a un

elemento concreto del array, especificamos el nombre del array seguido del número

de índice del elemento en particular entre corchetes []. Observe que el primer

elemento del array está indexado como 0, no como 1.

En el siguiente ejemplo, queremos crear un array c que contenga 6 enteros (de c[0] a

c[5]).

c[0] 2

c[1] 5

c[2] 1

c[3] 43

c[4] 8

c[5] 66

Ésta es la declaración:

int[] c = new int[6]; //Reserva memoria para 6 enteros en el array c

c[0] = 2;

c[1] = 5;

…………………

O bien puede inicializar y declarar el array al mismo tiempo.

int [] c = {2, 5, 1, 43, 8, 66};

El array puede almacenar, no sólo tipos de datos primitivos, sino también objetos. Por

ejemplo:

Box[] boxArray = new Box[3];

Cada objeto del array tiene un miembro de datos entero llamado length que devuelve

el número de elementos de dicho array. Por ejemplo:       

System.out.println(c.length); //se obtiene 6 como resultado

Los arrays presentan dos inconvenientes fundamentales:

· La longitud del array es fija. No es posible aumentarla o reducirla según se

necesite. La memoria se asigna según la longitud, incluso si el array no utiliza

todo el espacio.

· Sólo pueden contener elementos de un mismo tipo

Para salvar estas limitaciones, Java creó una clase llamada Vector en el paquete

java.util

Al igual que un array, un vector es una colección de objetos, pero:

· Un vector puede aumentar su longitud automáticamente cuando lo necesite.

· Un vector puede contener elementos de distintos tipos siempre y cuando

cada uno sea un objeto (pero NO un tipo de datos primitivo; no es posible

incluir integers o doubles en un vector).

· Es posible acceder a un vector, agregarlo, modificarlo y consultarlo

utilizando métodos de la clase Vector

A continuación, mostramos algunos de los métodos más utilizados:

· Vector(int initialCapacity)

· add(Object element)

· elementAt(int index)

· get(int index)

· isEmpty()

· remove(int index)

· size()

Tenga en cuenta que la longitud de un vector v es v.size(), no v.length

Aquí tenemos un ejemplo de uso de la clase Vector

import java.util.*;

class TestVector{

public static void main (String[] args) {

Vector bv = new Vector(2); //crea un vector con capacidad 2

System.println(“Capacidad = “ + bv.capacity() + “ tamaño = “ + bv.size());

Box b1 = new Box(1.0, 2.0, 3.0);

Box b2 = new Box();

Box b3 = new Box(0.5, 1.5, 2.5);

bv.add(b1); //agrega b1 al final del vector

bv.add(b2); //agrega b2 al final del vector

bv.add(b3); //agrega b3 al final del vector

System.println (“Capacidad = “ + bv.capacity() + “ tamaño = “ + bv.size());

System.println (“Ancho del primer elemento = “ +

((Box)bv.firstElement()).getWidth());

System.println (“Ancho del segundo elemento = “ +

((Box)bv.elementAt(1)).getWidth());

System.println (“Ancho del último elemento = “ +

((Box)bv.lastElement()).getWidth());

bv.remove(2);

System.println(“Capacidad = “ + bv.capacity() + “ tamaño = “ + bv.size());

}

Los datos de salida son:

Capacidad = 2 tamaño = 0

Capacidad = 4 tamaño = 3

Ancho del primer elemento = 1.0

Ancho del segundo elemento = 0.0

Ancho del último elemento= 0.5

Capacidad = 4 tamaño 2