Matriz en java

Como delarar una matriz (array)

Una matriz (o array) es básicamente una lista de variables del mismo tipo. Para crear una matriz, primero declara de qué tipo de datos consistirán las variables en tu matriz, luego el nombre de la matriz. El sintaxis es:

(tipo de dato) nombre_variable [ ];

Aquí primero declaramos cuál será el tipo de datos de todas las variables en la matriz. Luego nombraremos la colección de estas variables que son la matriz.

String nombres[];

         Ahora, aunque esta declaración establece  nombres como una matriz, no existe ninguna matriz en la memoria. Para que exista esta matriz, tenemos que vincularla a la memoria usando la palabra clave new. Esto se verá como lo siguiente:

String nombres= new String [10];

          Aquí asignamos una de cadenas de 10 elementos y las vinculamos a el variable nombres.

Ejemplos de una matriz unidimensionalales:

				
					 // Programas creando y manipulando matrices(arrays) unidimensionales 
//////////////////////////////////////////////////
// Ejemplo 1: ejemplo de programación donde creamos y
//imprimimos una matriz unidimensional de nombres de estudiantes 
// 
//////////////////////////////////////////////////
 
import java.io.*;
import java.util.*;
class Nombres {
	public static void main(String[] args)
	{
		// iniciamos una matriz
		String nombres[];
		nombres= new String[5];

		// populamos la matriz con cadenas
		nombres[0]="jose";
		nombres[1]="anna";
		nombres[2]="diego";
		nombres[3]="luis";
		nombres[4]="beatriz";
		
		// imprimimos la matriz
		for(int i=0;i<nombres.length;i++ )
		    System.out.println(nombres[i]);
		//salida: jose anna diego luis beatriz
 
	}
}
//////////////////////////////////////////////////
// Ejemplo 2: Aqui declaramos la matriz numeros y al mismo
// tiempo lo populamos en la misma linea de codigo. Entonces 
// encontramos la suma the estos numeros.
// 
//////////////////////////////////////////////////
import java.io.*;
class Numeros{
    public static void main(String[] args)
	{
	    int numeros[] = {3,2,5,66,8,2,33,55,62,14};
	    int suma=0;
	    
	    for(in i = numeros.length;i++)
	        suma = suma + numeros[i]; 
	        System.out.print("La suma de los numeros es"+ suma);
	}
}
				
			

Ejemplos de matrices multidimensionalales:

				
					// Programas creando y manipulando matrices (arrays) multidimensionales 
//////////////////////////////////////////////////
// Ejemplo 1: ejemplo de programación donde creamos y
//imprimimos un array multidimensional de numeros
// 
//////////////////////////////////////////////////
 import java.util.*;
class Numeros {
	public static void main(String[] args)
	{
		// iniciamos una matriz
		int numeros[][];
		numeros= new int[5][5];

		// populamos la matriz con numeros
		numeros[0][4]=10;
		numeros[1][3]=9;
		numeros[2][2]=8;
		numeros[3][1]=7;
		numeros[4][0]=6;
		// imprimimos la matriz
		for(int i=0;i<5;i++ )
		    {
	        for(int j=0;j<5;j++ )
		         System.out.print(" "+numeros[i][j]);
		    System.out.println();
		    }
/*salida: 
 0 0 0 0 10
 0 0 0 9 0
 0 0 8 0 0
 0 7 0 0 0
 6 0 0 0 0 */
 
	}
}
// Ejemplo 2: ejemplo de programación donde creamos una matriz
// multidimensional. Despues agregamos y imprimimos los numeros 
// en cada fila.
// 
//////////////////////////////////////////////////
 class SumaArray {
	public static void main(String[] args)
	{

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

		for (int i = 0; i < 4; i++) {
		    int t= 0;
			for (int j = 0; j < 4; j++) {
				t+=arr[i][j];	
				}
			System.out.println("La suma de los numeros de la fila "+ i +" es: "+t); 
		}
	}
}
// Salida: 
//La suma de los numeros de la fila 0 es: 10
//La suma de los numeros de la fila 1 es: 18
//La suma de los numeros de la fila 2 es: 22
//La suma de los numeros de la fila 3 es: 30

				
			

Busqueda Linear

  La busqueda lineal es un algoritmo de busqueda secuencial que comienza en un extremo y recorre cada elemento de una lista hasta encontrar el elemento deseado, de lo contrario la busqueda continua hasta el final del conjunto de datos. Es el algoritmo de busqueda mas sencillo de implementar cuando se buscan matrices.
				
					// Programa usando busqueda lineal//
////////////////////////////////////
// Busquamos x in arr[]. Si x
// esta presente entonces devuelve su
// ubicacion, en caso contrario, devuelve
//  -1

class BusquedaLineal {
	public static void main(String args[])
	{
		int arr[] = { 2, 33, 4, 10, 40 , 44, 1, 86 };
		int x = 33;

		// llama a la funcion search 
		int resultado = search(arr, x);
		if (resultado == -1)
			System.out.print(
				"El elemento no esta presente en la matriz.");
		else
			System.out.print("El elemento esta presente en el indice: "
							+ resultado);
	}
	public static int search(int arr[], int x)
	{
		int N = arr.length;
		for (int i = 0; i < N; i++) {
			if (arr[i] == x)
				return i;
		}
		return -1;
	}
}

				
			

   Busqueda Binaria

  La busqueda binaria es un algoritmo de búsqueda que utiliza una matriz ordenado y divide repetidamente la sección de una matriz que se busca por la mitad. Utilizamos la información de que la matriz está ordenado para reducir la complejidad temporal a O(Log n).
				
					// Programa usando busqueda binaria//
////////////////////////////////////

// implementacion de una busqueda binaria
class BinarySearch {
	public static void main(String args[])
	{
		BinarySearch ob = new BinarySearch();
		int arr[] = { 2, 3, 4, 10, 40 };
		int n = arr.length;
		int x = 10;
		int resultado = ob.binarySearch(arr, 0, n - 1, x);
		if (resultado == -1)
			System.out.println("Elemento no esta presente");
		else
			System.out.println("Elemento en indice "
							+ resultado);
	}
	// regresa  indice de x si existe en arr[l..
	// r], si no existe regresa -1
	int binarySearch(int arr[], int l, int r, int x)
	{
		if (r >= l) {
			int mid = l + (r - l) / 2;

			// si el elemento existe en el indice central regresa el indice
			if (arr[mid] == x)
				return mid;

			// Si el elemento es menor que mid, buscamos el
			// valor en la subarray de la izquierda
			if (arr[mid] > x)
				return binarySearch(arr, l, mid - 1, x);
		    // De otra manera buscamos 
			// el elemento en el subarray de la derecha
			return binarySearch(arr, mid + 1, r, x);
		}

		//  Si no existe el valor en el array regresa -1
		return -1;
	}

}