[Aporte] ....::: Clase Arrays del paquete java.util :::...

Hola

...::: Clase Arrays :::...

La clase arrays del paquete java.util contiene varios métodos static para manipular matrices. Esta clase se deriva directamente de Object.

Esta clase intenta solventar alguno de los problemas que pueden surgir al trabajar con arrays, como la ordenación o la búsqueda.

binarySearch
equals
fill
sort
asList

Nota:
Si es necesario tendriamos q importar la clase.

Código

import java.util.Arrays;

Nota:
Utilisaremos sta clase para ingresar datos x teclado..! si es necesaio tambien tendremos q importarla

Código

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
 
public class Leer
{
  public static String dato()
  {
    String sdato = "";
    try
    {
      // Definir un flujo de caracteres de entrada: flujoE
      InputStreamReader isr = new InputStreamReader(System.in);
      BufferedReader flujoE = new BufferedReader(isr);
      // Leer. La entrada finaliza al pulsar la tecla Entrar
      sdato = flujoE.readLine();
    }
    catch(IOException e)
    {
      System.err.println("Error: " + e.getMessage());
    }
    return sdato; // devolver el dato tecleado
  }
 
  public static short datoShort()
  {
    try
    {
      return Short.parseShort(dato());
    }
    catch(NumberFormatException e)
    {
      return Short.MIN_VALUE; // valor más pequeño
    }
  }
 
  public static int datoInt()
  {
    try
    {
      return Integer.parseInt(dato());
    }
    catch(NumberFormatException e)
    {
      return Integer.MIN_VALUE; // valor más pequeño
    }
  }
 
  public static long datoLong()
  {
    try
    {
      return Long.parseLong(dato());
    }
    catch(NumberFormatException e)
    {
      return Long.MIN_VALUE; // valor más pequeño
    }
  }
 
  public static float datoFloat()
  {
    try
    {
      Float f = new Float(dato());
      return f.floatValue();
    }
    catch(NumberFormatException e)
    {
      return Float.NaN; // No es un Número; valor float.
    }
  }
 
  public static double datoDouble()
  {
    try
    {
      Double d = new Double(dato());
      return d.doubleValue();
    }
    catch(NumberFormatException e)
    {
      return Double.NaN; // No es un Número; valor double.
    }
  }
 
}

BinarySearch

Este método permite buscar un valor en una matriz que esté ordenada ascendentemente utilizando el algoritmo de búsqueda binaria. Se trata de un algoritmo muy eficiente en cuanto a que el tiempo requerido para utilizar una búsqueda es muy pequeño. La sintaxis expresada de forma genérica para utilizar este método es la siguiente:

Código

static int binarySearch (tipo[]m, tipo clave)

Donde m representa la matriz, clave es el valor que se desea buscar del mismo tipo que los elementos de la matriz, y tipo es cualquier tipo de datos de los siguientes: byte, char, short, int, long, float, double y Objet.

El valor devuelto es un entero correspondiente al índice del elemento que coincide cono el valor buscado. Si el valor buscado no se encuentra, entonces el valor devuelto es: -(punto de inserción). El punto de insercion empieza a contar desde "1", y no desde "0"

Como ejemplo, analicemos el siguiente código:

Código

int vector[]={2,4,6,8,10,12,14,16,18,20}; //vector ordenado ascendentemente
int i;
i = Arrays.binarySearch(a, 6); // Devuelve i = 2 que es su posicion en la matriz.
i = Arrays.binarySearch(a, 7); //Devuelve i=-4 al no existir devuelve en negativo el lugar que le corresponderia, enpezando a contar desde 1
i = Arrays.binarySearch(a, 1); //Devuelve i=-1 al no existir devuelve en negativo el lugar que le corresponderia en en array, enpezando a contar desde 1
i = Arrays.binarySearch(a, 31); //Devuelve i=-11 al no existir devuelve en negativo el lugar que le corresponderia en en array, enpezando a contar desde 1

Codigo completo del ejemplo:

Código

 
        //Declaramos e Inicializamos el Vector
        int vector[]={2,4,6,8,10,12,14,16,18,20};
 
        //Cabecera
        System.out.print("*******************************\n");
        System.out.print("******** Clase Arrays *********\n");
        System.out.print("*******************************\n\n");
        System.out.println("Valores ");
        System.out.println("-------\n");
 
        //Recorremos el vector para Mostrarlo
        for(int i=0;i<vector.length;i++)
        {
            System.out.print(" "+vector[i]);//Mostramos los valores
        }
 
        //Metodos Static BinarySearcho de la Clase Arrays
        //SubCabecera
        System.out.print("\n\nBinarySearch\n");
        System.out.print("-------------");
        //Esta variable contendra al valor a buscar en el vector
        int x;
        //Validamos que el valor a buscar este dentro del
        //rango del vector
        do
        {
            System.out.print("\n\n\tBuscar --> ");
            x=Leer.datoInt();
       }while(x<2 || x>32);
       //Mostramos la Posicion del valor, dentro del vector
       System.out.println("\tPosicion --> "+Arrays.binarySearch(vector, x));

equals

Este método permite verificar si dos matrices son iguales. Dos matrices se consideran iguales cuando ambas tienen el mismo número de elementos y en el mismo orden. Así mismo, dos matrices también son consideradas iguales si sus referencias valen null. La sintaxis para utilizar este método, expresada de forma genérica, es la siguiente:

Código

static boolean equals(tipo[]m1, tipo[]m2)

En esta estructura m1 y m2 son matrices del mismo tipo. Tipo es cualquier tipo de datos de los siguientes: boolean, byte, char, short, int, long, float, double y Objet.

El valor devuelto será true si ambas matrices son iguales y false en caso contrario.

Como ejemplo, se puede probar el resultado que produce el siguiente código:

Código

 
        //Declaramos e Inicializamos el Vector
        int vector_1[]={2,4,6,8,10,12,14,16,18,20};
        int vector_2[]={2,4,6,8,10,12,14,16,18,20};
 
        //Cabecera
        System.out.print("***************************************\n");
        System.out.print("************ Clase Arrays *************\n");
        System.out.print("***************************************\n\n");
        System.out.println("Valores ");
        System.out.println("-------\n");
 
        System.out.print("Vector 1 -->");
        //Recorremos el vector_1 para Mostrarlo
        for(int i=0;i<vector_1.length;i++)
        {
            System.out.print(" "+vector_1[i]);//Mostramos los valores
        }
        System.out.print("\nVector 2 -->");
        //Recorremos el vector_2 para Mostrarlo
        for(int i=0;i<vector_1.length;i++)
        {
            System.out.print(" "+vector_1[i]);//Mostramos los valores
        }
 
        //Metodos Static equals de la Clase Arrays
        //SubCabecera
        System.out.print("\n\nEquals\n");
        System.out.print("------\n");
 
        if(Arrays.equals(vector_1, vector_2))
        {
            System.out.println("\tLos Arrays son Iguales");
        }
        else
        {
            System.out.println("\tLos Arrays son Iguales");
        }

fill

Este método permite asignar un valor a todos los elementos de una matriz, o bien a cada elemento de un rango especificado. La sintaxis expresada de forma genérica para utilizar este método es la siguiente:

Código

static void fill(tipo[] m, tipo valor)
static void fill (tipo[] m, intdesdeInd, int hastaInd, tipo valor)

En la anterior sintaxis m es la matriz y valor es el valor a asignar. Cuando sólo queramos asignar el valor a un rango de elementos, utilizaremos el segundo formato de fill donde desdeInd y hastaInd definen ese rango, tipo es cualquier tipo de datos de los siguientes: boolean, byte, char, short, int, long, float, double y Objet.

Un ejemplo de cómo utilizar este método es:

Código

 
        //Declaramos e Inicializamos el Vector
        int vector[]={2,4,6,8,10,12,14,16,18,20};
 
        //Cabecera
        System.out.print("***************************************\n");
        System.out.print("************ Clase Arrays *************\n");
        System.out.print("***************************************\n\n");
        System.out.println("Valores ");
        System.out.println("-------\n");
 
        //Recorremos el vector para Mostrarlo
        for(int i=0;i<vector.length;i++)
        {
            System.out.print(" "+vector[i]);//Mostramos los valores
        }
        //Metodos Static Fill de la Clase Arrays
        //SubCabecera
        System.out.print("\n\nFill\n");
        System.out.print("----\n\n");
 
         System.out.print(". Todos los valores del vector\n");
        //damos el valor "0", a todos los elementos del vector
        Arrays.fill(vector, 0);
 
        //Recorremos el vector para verificar el cambio de valor
        for(int i=0;i<vector.length;i++)
        {
            System.out.print(" "+vector[i]);//Mostramos los valores
        }
 
//        System.out.print("\n. Un rango de valores del vector\n");
//        //damos el valor "0", un rango de valores del vector
//        Arrays.fill(vector,2, 6, 0);
//
//        //Recorremos el vector para verificar el cambio de valor
//        for(int i=0;i<vector.length;i++)
//        {
//            System.out.print(" "+vector[i]);//Mostramos los valores
//        }

sort

[/size]
Este método permite ordenar los elementos de una matriz en orden ascendente utilizando el algoritmo quicksort. Este método es muy eficiente en cuanto a que el tiempo requerido para realizar la ordenación es mínimo. La sintaxis expresada de forma genérica para utilizar este método es la siguiente:

Código

static void sort(tipo[]m)
static void sort(tipo[]m, int desdeInd, int hastaInd)

En la anterior sintaxis m es la matriz a ordenar. Cuando sólo queramos ordenar un rango de elementos, utilizaremos el segundo formato de sort donde desdeInd y hastaInd definen los límites de ese rango. Tipo es cualquier objeto de los siguientes: boolean, byte, char, short, int, long, float, double y Objet.

Como ejemplo práctico comprobar el resultado que produce este código:

Código

 
        //Declaramos y Construimos al vector
        int vector[]=new int[10];
 
        //Cabecera
        System.out.print("***************************************\n");
        System.out.print("************ Clase Arrays *************\n");
        System.out.print("***************************************\n\n");
        System.out.println("Valores ");
        System.out.println("-------\n");
 
        //Asignamos valores al vector
        for(int i=0;i<vector.length;i++)
        {
            vector[i]=(int)(Math.random()*(10-0)+0);//valores aleatorios
        }
        //Recorremos el vector para Mostrarlo
        for(int i=0;i<vector.length;i++)
        {
            System.out.print(" "+vector[i]);//Mostramos los valores
        }
        //Metodos Static Sort de la Clase Arrays
        //SubCabecera
        System.out.print("\n\nSort\n");
        System.out.print("----\n");
 
//         System.out.print("\n. Valores del vector ordenados\n");
//        //damos el valor "0", a todos los elementos del vector
//        Arrays.sort(vector);
//
//        //Recorremos el vector para verificar el cambio de valor
//        for(int i=0;i<vector.length;i++)
//        {
//            System.out.print(" "+vector[i]);//Mostramos los valores
//        }
 
        System.out.print("\n. Un rango de valores del vector ordenados\n");
        //Ordenamos un rango del vector
        Arrays.sort(vector,2,6);
 
        //Recorremos el vector para verificar el cambio de valor
        for(int i=0;i<vector.length;i++)
        {
            System.out.print(" "+vector[i]);//Mostramos los valores
        }
    }

asList

Devuelve una lista de tamaño fijo respaldado por la matriz especificada. Este método actúa como puente entre las API basada en arreglos y basada en la colección-, en combinación con Collection.toArray. La lista devuelta es serializable y aplica RandomAccess.

Código

public static <T> List<T> asList(T... a)

Pero mucho cuidado, este método nos crea una lista de tamaño fijo, y por detrás sigue funcionando sobre nuestro array (en realidad es una implementación especial de AbstractList). Veámoslo con dos ejemplos.

Este trozo de código no va a funcionar, la lista es de tamaño fijo y se lanza una excepción.

Código

 
        String[] vector = { "a","b","c","d","e" };
	List<String> lista = Arrays.asList(vector);
	lista.add("z");

Las modificaciones que hagamos en el array original se reflejarán en la lista (y viceversa).

Código

 
        //Declaramos y Construimos al vector
        String vector[]= {"a","b","c","d","e"};
 
        //Cabecera
        System.out.print("***************************************\n");
        System.out.print("************ Clase Arrays *************\n");
        System.out.print("***************************************\n\n");
        System.out.println("Valores ");
        System.out.println("-------\n");
 
        //Recorremos el vector para Mostrarlo
        for(int i=0;i<vector.length;i++)
        {
            System.out.print(" "+vector[i]);//Mostramos los valores
        }
        //Metodos Static asList de la Clase Arrays
        //SubCabecera
        System.out.print("\n\nasList\n");
        System.out.print("-------\n");
 
        //Creamos la lista
        List<String> lista= Arrays.asList(vector);
        System.out.println(lista);
 
        //modificamos un valor del vector
        vector[1]="z";
        System.out.println(lista);
        //modificamos un valor del vector
        vector[4]="x";
        System.out.println(lista)

En este caso la salida producida será:

asList
-------
[a, b, c, d, e]
[a, z, c, d, e]
[a, z, c, d, x]

Nota :
cuidado con utilizar este método para convertir un array a una lista para, por ejemplo, cumplir con la firma de métodos de terceros que puedan intentar modificarla.

Salu2