Manejo de matrices y vectores

Manejo de matrices y vectores.

Los vectores.

Imaginemos que tenemos que hallar el promedio de 10 números que introduzca el usuario (o realizar cualquier otra operación con ellos). Parece evidente que tiene que haber una solución más cómoda que definir 10 variables distintas y escribir 10 veces las instrucciones de avisar al usuario, leer los datos que teclee, y almacenar esos datos. Si necesitamos manejar 100, 1.000 o 10.000 datos, resulta todavía más claro que no es eficiente utilizar una variable para cada uno de esos datos.

Por eso se emplean los arrays (o arreglos). Un array es una variable que puede contener varios dato del mismo tipo. Para acceder a cada uno de esos datos emplearemos corchetes. Por ejemplo, si definimos una variable llamada "m" que contenga 10 números enteros, accederemos al primero de estos números como m[0], el último como m[9] y el quinto como m[4] (se empieza a numerar a desde 0 y se termina en n-1). Veamos un ejemplo que halla la media de cinco números (con decimales, "double"):

         // Array1.java
         // Aplicación de ejemplo con Arrays
         // Introducción a Java

         class Array1 {
             public static void main( String args[] ) {

                double a[] = { 10, 23.5, 15, 7, 8.9 };
                double total = 0;
                int i;

                for (i=0; i<5; i++)
                  total += a[i];

                System.out.println( "La media es:" );
                System.out.println( total / 5 );
             }
         }

Para definir la variable podemos usar dos formatos:  "double a[]" (que es la sintaxis habitual en C y C++) o bien "double[] a" (que es la sintaxis recomendada en Java, y posiblemente es una forma más "razonable" de escribir "la variable a es un array de doubles").

Nota: Quien venga de C y/o C++ tiene que tener en cuenta que en Java no son válidas definiciones como float a[5]; habrá que asignar los valores como acabamos de hacer, o reservar espacio de la forma que veremos a continuación.

Lo habitual no será conocer los valores en el momento de teclear el programa, como hemos hecho esta vez. Será mucho más frecuente que los datos los teclee el usuario o bien que los leamos de algún fichero, los calculemos, etc.  En este caso, tendremos que reservar el espacio, y los valores los almacenaremos a medida que vayamos conociéndolos.

Para ello, primero declararíamos que vamos a utilizar un array, así:

double[] datos;

y después reservaríamos espacio (por ejemplo, para 1.000 datos) con

datos = new double [1000];

Estos dos pasos se pueden dar en uno solo, así:

double[] datos = new double [1000];

y daríamos los valores de una forma similar a la que hemos visto en el ejemplo anterior:

datos[25] = 100 ; datos[0] = i*5 ; datos[j+1] = (j+5)2 = new double [1000];

Vamos a ver un ejemplo algo más completo, con tres arrays de números enteros, llamados a, b y c. A uno de ellos (a) le daremos valores al definirlo, otro lo definiremos en dos pasos (b) y le daremos fijos, y el otro lo definiremos en un paso y le daremos valores calculados a partir de ciertas operaciones:

         // Array2.java
         // Aplicación de ejemplo con Arrays
         // Introducción a Java

         class Array2 {
             public static void main( String args[] ) {

                int i;  // Para repetir con bucles "for"
 

                // ------  Primer array de ejemplo
                int[] a = { 10, 12345, -15, 0, 7 };

                System.out.println( "Los valores de a son:" );
                for (i=0; i<5; i++)
                  System.out.println( a[i] );

                // ------  Segundo array de ejemplo
                int[] b;
                b = new int [3];
                b[0] = 15; b[1] = 132; b[2] = -1;

                System.out.println( "Los valores de b son:" );
                for (i=0; i<3; i++)
                  System.out.println( b[i] );

                // ------  Tercer array de ejemplo
                int j = 4;
                int[] c = new int[j];

                for (i=0; i<j; i++)
                  c[i] = (i+1)*(i+1);

                System.out.println( "Los valores de c son:" );
                for (i=0; i<j; i++)
                  System.out.println( c[i] );
             }
         }
 

Matrices.

 

Las matrices se definen, como un arreglo bidimensional, en donde tenemos un número de reglones N y un número de columnas M. La representación matemática de una matriz es :

 

a11

a12

...

a1M

a21

a22

...

a2M

...

...

...

...

aN1

aN2

...

aNM

 

Para hacer la definición en Java de este arreglo hacemos

 

    double A[][] = new double [N][M];

 

donde A es el nombre del arreglo N el número de renglones y M el número de columnas.

 

Para hacer referencia al elemento en el i-esimo renglón y la j-esima columna hacemos A[i][j].

 

Otra forma de hacer la definición de un arreglo es mediante la siguiente instrucción

 

    double a[][] = {{1,2,3}, {4,5,6}, {7,8,9}};

 

esta instrucción crea un arreglo de 3 renglones con 3 columnas y los elementos lo dispone de la siguiente manera

 

 

 

1

2

3

A

=

4

5

6

 

 

7

8

9

 

Ejemplo.

 

Hacer un programa que almacene la matriz anterior en un arreglo, la eleve al cuadrado e imprima el resultado en la pantalla.

 

class arreglos

{

  static public void main(String args[])

  {

    double a[][] = {{1,2,3}, {4,5,6}, {7,8,9}};

    double b[][] = new double [3][3];

    int i, j;

 

    for(i=0; i< 3; i++)

      for(j=0; j<3; j++)

        b[i][j] = a[i][j] * a[i][j];

 

 

    for(i=0; i< 3; i++)

    {

      for(j=0; j<3; j++)

        System.out.print(b[i][j] + " ");

      System.out.println("");

    }

 

  }

}

 


 

Las cadenas de texto.

Una cadena de texto (en inglés, "string") es un bloque de letras, que usaremos para poder almacenar palabras y frases. En algunos lenguajes, podríamos utilizar un "array" de "chars" para este fin, pero en Java no es necesario, porque tenemos un tipo "cadena" específico ya incorporado en el lenguaje.

Realmente en Java hay dos "variantes" de las cadenas de texto: existe una clase llamada "String" y otra clase llamada "StringBuffer". Un "String" será una cadena de caracteres constante, que no se podrá modificar (podremos leer su valor, extraer parte de él, etc.; para cualquier modificación, realmente Java creará una nueva cadena), mientras que un "StringBuffer" se podrá modificar "con más facilidad" (podremos insertar letras, dar la vuelta a su contenido, etc) a cambio de ser ligeramente menos eficiente (más lento).

Vamos a ver las principales posibilidades de cada uno de estos dos tipos de cadena de texto y luego lo aplicaremos en un ejemplo.

Podemos "concatenar" cadenas (juntar dos cadenas para dar lugar a una nueva) con el signo +, igual que sumamos números. Por otra parte, los métodos de la clase String son:
 

Método

Cometido

length()

Devuelve la longitud (número de caracteres) de la cadena

charAt (int pos)

Devuelve el carácter que hay en una cierta posición

toLowerCase()

Devuelve la cadena convertida a minúsculas

toUpperCase()

Devuelve la cadena convertida a mayúsculas

substring(int desde,
  int cuantos)

Devuelve una subcadena: varias letras a partir de una posición dada

replace(char antiguo,
  char nuevo)

Devuelve una cadena conun carácter reemplazado por otro

trim()

Devuelve una cadena sin espacios de blanco iniciales ni finales

startsWith(String
  subcadena)

Indica si la cadena empieza con una cierta subcadena

endsWith(String
  subcadena)

Indica si la cadena termina con una cierta subcadena

indexOf(String subcadena,
  [int desde])

Indica la posición en que se encuentra una cierta subcadena
(buscando desde el principio, a partir de una posición opcional)

lastIndexOf(String
  subcadena, [int desde])

Indica la posición en que se encuentra una cierta subcadena
(buscando desde el final, a partir de una posición opcional)

valueOf( objeto )

Devuelve un String que es la representación como texto del
objeto que se le indique (número, boolean, etc.)

concat(String cadena)

Devuelve la cadena con otra añadida a su final (concatenada)
También se pueden concatenar cadenas con "+"

equals(String cadena)

Mira si las dos cadenas son iguales (lo mismo que "= =")

equals-IgnoreCase(
  String cadena)

Comprueba si dos cadenas son iguales, pero despreciando
las diferencias entre mayúsculas y minúsculas

compareTo(String cadena2)

Compara una cadena con la otra (devuelve 0 si son iguales,
negativo si la cadena es "menor" que cadena2 y positivo
si es "mayor").

Como se ve, en ningún momento estamos modificando el String de partida. Eso sí, en muchos de los casos creamos un String modificado a partir del original.

El método "compareTo" se basa en el órden lexicográfico: una cadena que empiece por "A" se considerará "menor" que otra que empiece por la letra "B"; si la primera letra es igual en ambas cadenas, se pasa a comparar la segunda, y así sucesivamente. Las mayúsculas y minúsculas se consideran diferentes.

Hay alguna otra posibilidad, de uso menos sencillo, que no veremos (al menos por ahora), como la de volcar parte del String en un array de chars o de bytes.
 

Los métodos de la clase StringBuffer son:
 
 

Método

Cometido

length()

Devuelve la longitud (número de caracteres) de la cadena

setLength()

Modifica la longitud de la cadena (la trunca si hace falta) 

charAt (int pos)

Devuelve el carácter que hay en una cierta posición

setCharAt(int pos, char
  letra)

Cambia el carácter que hay en una cierta posición

toString()

Devuelve el StringBuffer convertido en String

reverse()

Cambia el orden de los caracteres que forman la cadena

append( objeto )

Añade otra cadena, un número, etc. al final de la cadena

insert(int pos, objeto)

Añade otra cadena, un número, etc. en una cierta posición

Al igual que ocurre con los strings, existe alguna otra posibilidad más avanzada, que no he comentado,  como la de volcar parte del String en un array de chars, o de comprobar la capacidad (tamaño máximo) que tiene un StringBuffer o fijar dicha capacidad.
 
 

Un comentario extra sobre los Strings: Java convertirá a String todo aquello que indiquemos entre comillas dobles. Así, son válidas expresiones como "Prueba".length() y también podemos concatenar varias expresiones dentro de una orden System.out.println:

            System.out.println( "Texto: " + texto1 + 5  + 23.5 );
 
 

Vamos a ver un ejemplo que aplique la mayoría de todo esto:

         // Strings1.java
         // Aplicación de ejemplo con Strings
         // Introducción a Java,  

         class Strings1 {
             public static void main( String args[] ) {

                String texto1 = "Hola";                 // Forma "sencilla"
                String texto2 = new String("Prueba");   // Usando un constructor

                System.out.println( "La primera cadena de texto es :" );
                System.out.println( texto1 );

                System.out.println( "Concatenamos las dos: " + texto1 + texto2 );
                System.out.println( "Concatenamos varios: " + texto1 + 5 + " " + 23.5 );
                System.out.println( "La longitud de la segunda es: " + texto2.length() );
                System.out.println( "La segunda letra de texto2 es: "
                  + texto2.charAt(1) );
                System.out.println( "La cadena texto2 en mayúsculas: "
                  + texto2.toUpperCase() );
                System.out.println( "Tres letras desde la posición 1: "
                  + texto2.substring(1,3) );
                System.out.println( "Comparamos texto1 y texto2: "
                  + texto1.compareTo(texto2) );

                if (texto1.compareTo(texto2) < 0)
                  System.out.println( "Texto1 es menor que texto2" );

                StringBuffer texto3 = new StringBuffer("Otra prueba");

                texto3.append(" mas");
                System.out.println( "Texto 3 ahora es: " + texto3 );
                texto3.insert(2, "1");
                System.out.println( "Y ahora es: " + texto3 );
                texto3.reverse();
                System.out.println( "Y ahora: " + texto3 );
 

             }
         }
 

El resultado de este programa sería el siguiente:

La primera cadena de texto es :
Hola
Concatenamos las dos: HolaPrueba
Concatenamos varios: Hola5 23.5
La longitud de la segunda es: 6
La segunda letra de texto2 es: r
La cadena texto2 en mayúsculas: PRUEBA
Tres letras desde la posición 1: ru
Comparamos texto1 y texto2: -8
Texto1 es menor que texto2
Texto 3 ahora es: Otra prueba mas
Y ahora es: Ot1ra prueba mas
Y ahora: sam abeurp ar1tO
 

Regresar.