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

[horny3]

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 (java) [Seleccionar] Expandir

import java.util.Arrays;

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

Código (java) [Seleccionar] Expandir


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 (java) [Seleccionar] Expandir

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 (java) [Seleccionar] Expandir


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 (java) [Seleccionar] Expandir



       //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 (java) [Seleccionar] Expandir

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 (java) [Seleccionar] Expandir


     
       //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 (java) [Seleccionar] Expandir

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 (java) [Seleccionar] Expandir



       //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 (java) [Seleccionar] Expandir

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 (java) [Seleccionar] Expandir



       //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 (java) [Seleccionar] Expandir

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 (java) [Seleccionar] Expandir


       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 (java) [Seleccionar] Expandir



       //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