elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.

 

 


Tema destacado: Guía actualizada para evitar que un ransomware ataque tu empresa


+  Foro de elhacker.net
|-+  Programación
| |-+  Programación General
| | |-+  Java
| | | |-+  [Aporte] ....::: Clase Arrays del paquete java.util :::...
0 Usuarios y 1 Visitante están viendo este tema.
Páginas: [1] Ir Abajo Respuesta Imprimir
Autor Tema: [Aporte] ....::: Clase Arrays del paquete java.util :::...  (Leído 3,045 veces)
horny3

Desconectado Desconectado

Mensajes: 11



Ver Perfil
[Aporte] ....::: Clase Arrays del paquete java.util :::...
« en: 24 Septiembre 2012, 06:43 am »

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
  1. import java.util.Arrays;

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

Código
  1. import java.io.BufferedReader;
  2. import java.io.IOException;
  3. import java.io.InputStreamReader;
  4.  
  5. public class Leer
  6. {
  7.  public static String dato()
  8.  {
  9.    String sdato = "";
  10.    try
  11.    {
  12.      // Definir un flujo de caracteres de entrada: flujoE
  13.      BufferedReader flujoE = new BufferedReader(isr);
  14.      // Leer. La entrada finaliza al pulsar la tecla Entrar
  15.      sdato = flujoE.readLine();
  16.    }
  17.    catch(IOException e)
  18.    {
  19.      System.err.println("Error: " + e.getMessage());
  20.    }
  21.    return sdato; // devolver el dato tecleado
  22.  }
  23.  
  24.  public static short datoShort()
  25.  {
  26.    try
  27.    {
  28.      return Short.parseShort(dato());
  29.    }
  30.    catch(NumberFormatException e)
  31.    {
  32.      return Short.MIN_VALUE; // valor más pequeño
  33.    }
  34.  }
  35.  
  36.  public static int datoInt()
  37.  {
  38.    try
  39.    {
  40.      return Integer.parseInt(dato());
  41.    }
  42.    catch(NumberFormatException e)
  43.    {
  44.      return Integer.MIN_VALUE; // valor más pequeño
  45.    }
  46.  }
  47.  
  48.  public static long datoLong()
  49.  {
  50.    try
  51.    {
  52.      return Long.parseLong(dato());
  53.    }
  54.    catch(NumberFormatException e)
  55.    {
  56.      return Long.MIN_VALUE; // valor más pequeño
  57.    }
  58.  }
  59.  
  60.  public static float datoFloat()
  61.  {
  62.    try
  63.    {
  64.      Float f = new Float(dato());
  65.      return f.floatValue();
  66.    }
  67.    catch(NumberFormatException e)
  68.    {
  69.      return Float.NaN; // No es un Número; valor float.
  70.    }
  71.  }
  72.  
  73.  public static double datoDouble()
  74.  {
  75.    try
  76.    {
  77.      Double d = new Double(dato());
  78.      return d.doubleValue();
  79.    }
  80.    catch(NumberFormatException e)
  81.    {
  82.      return Double.NaN; // No es un Número; valor double.
  83.    }
  84.  }
  85.  
  86. }
  87.  

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

Codigo completo del ejemplo:

Código
  1.  
  2.        //Declaramos e Inicializamos el Vector
  3.        int vector[]={2,4,6,8,10,12,14,16,18,20};
  4.  
  5.        //Cabecera
  6.        System.out.print("*******************************\n");
  7.        System.out.print("******** Clase Arrays *********\n");
  8.        System.out.print("*******************************\n\n");
  9.        System.out.println("Valores ");
  10.        System.out.println("-------\n");
  11.  
  12.        //Recorremos el vector para Mostrarlo
  13.        for(int i=0;i<vector.length;i++)
  14.        {
  15.            System.out.print(" "+vector[i]);//Mostramos los valores
  16.        }
  17.  
  18.        //Metodos Static BinarySearcho de la Clase Arrays
  19.        //SubCabecera
  20.        System.out.print("\n\nBinarySearch\n");
  21.        System.out.print("-------------");
  22.        //Esta variable contendra al valor a buscar en el vector
  23.        int x;
  24.        //Validamos que el valor a buscar este dentro del
  25.        //rango del vector
  26.        do
  27.        {
  28.            System.out.print("\n\n\tBuscar --> ");
  29.            x=Leer.datoInt();
  30.       }while(x<2 || x>32);
  31.       //Mostramos la Posicion del valor, dentro del vector
  32.       System.out.println("\tPosicion --> "+Arrays.binarySearch(vector, x));
  33.  
  34.  

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
  1. 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
  1.  
  2.        //Declaramos e Inicializamos el Vector
  3.        int vector_1[]={2,4,6,8,10,12,14,16,18,20};
  4.        int vector_2[]={2,4,6,8,10,12,14,16,18,20};
  5.  
  6.        //Cabecera
  7.        System.out.print("***************************************\n");
  8.        System.out.print("************ Clase Arrays *************\n");
  9.        System.out.print("***************************************\n\n");
  10.        System.out.println("Valores ");
  11.        System.out.println("-------\n");
  12.  
  13.        System.out.print("Vector 1 -->");
  14.        //Recorremos el vector_1 para Mostrarlo
  15.        for(int i=0;i<vector_1.length;i++)
  16.        {
  17.            System.out.print(" "+vector_1[i]);//Mostramos los valores
  18.        }
  19.        System.out.print("\nVector 2 -->");
  20.        //Recorremos el vector_2 para Mostrarlo
  21.        for(int i=0;i<vector_1.length;i++)
  22.        {
  23.            System.out.print(" "+vector_1[i]);//Mostramos los valores
  24.        }
  25.  
  26.        //Metodos Static equals de la Clase Arrays
  27.        //SubCabecera
  28.        System.out.print("\n\nEquals\n");
  29.        System.out.print("------\n");
  30.  
  31.        if(Arrays.equals(vector_1, vector_2))
  32.        {
  33.            System.out.println("\tLos Arrays son Iguales");
  34.        }
  35.        else
  36.        {
  37.            System.out.println("\tLos Arrays son Iguales");
  38.        }
  39.  
  40.  

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
  1. static void fill(tipo[] m, tipo valor)
  2. 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
  1.  
  2.        //Declaramos e Inicializamos el Vector
  3.        int vector[]={2,4,6,8,10,12,14,16,18,20};
  4.  
  5.        //Cabecera
  6.        System.out.print("***************************************\n");
  7.        System.out.print("************ Clase Arrays *************\n");
  8.        System.out.print("***************************************\n\n");
  9.        System.out.println("Valores ");
  10.        System.out.println("-------\n");
  11.  
  12.        //Recorremos el vector para Mostrarlo
  13.        for(int i=0;i<vector.length;i++)
  14.        {
  15.            System.out.print(" "+vector[i]);//Mostramos los valores
  16.        }
  17.        //Metodos Static Fill de la Clase Arrays
  18.        //SubCabecera
  19.        System.out.print("\n\nFill\n");
  20.        System.out.print("----\n\n");
  21.  
  22.         System.out.print(". Todos los valores del vector\n");
  23.        //damos el valor "0", a todos los elementos del vector
  24.        Arrays.fill(vector, 0);
  25.  
  26.        //Recorremos el vector para verificar el cambio de valor
  27.        for(int i=0;i<vector.length;i++)
  28.        {
  29.            System.out.print(" "+vector[i]);//Mostramos los valores
  30.        }
  31.  
  32. //        System.out.print("\n. Un rango de valores del vector\n");
  33. //        //damos el valor "0", un rango de valores del vector
  34. //        Arrays.fill(vector,2, 6, 0);
  35. //
  36. //        //Recorremos el vector para verificar el cambio de valor
  37. //        for(int i=0;i<vector.length;i++)
  38. //        {
  39. //            System.out.print(" "+vector[i]);//Mostramos los valores
  40. //        }
  41.  
  42.  

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
  1. static void sort(tipo[]m)
  2. 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
  1.  
  2.        //Declaramos y Construimos al vector
  3.        int vector[]=new int[10];
  4.  
  5.        //Cabecera
  6.        System.out.print("***************************************\n");
  7.        System.out.print("************ Clase Arrays *************\n");
  8.        System.out.print("***************************************\n\n");
  9.        System.out.println("Valores ");
  10.        System.out.println("-------\n");
  11.  
  12.        //Asignamos valores al vector
  13.        for(int i=0;i<vector.length;i++)
  14.        {
  15.            vector[i]=(int)(Math.random()*(10-0)+0);//valores aleatorios
  16.        }
  17.        //Recorremos el vector para Mostrarlo
  18.        for(int i=0;i<vector.length;i++)
  19.        {
  20.            System.out.print(" "+vector[i]);//Mostramos los valores
  21.        }
  22.        //Metodos Static Sort de la Clase Arrays
  23.        //SubCabecera
  24.        System.out.print("\n\nSort\n");
  25.        System.out.print("----\n");
  26.  
  27. //         System.out.print("\n. Valores del vector ordenados\n");
  28. //        //damos el valor "0", a todos los elementos del vector
  29. //        Arrays.sort(vector);
  30. //
  31. //        //Recorremos el vector para verificar el cambio de valor
  32. //        for(int i=0;i<vector.length;i++)
  33. //        {
  34. //            System.out.print(" "+vector[i]);//Mostramos los valores
  35. //        }
  36.  
  37.        System.out.print("\n. Un rango de valores del vector ordenados\n");
  38.        //Ordenamos un rango del vector
  39.        Arrays.sort(vector,2,6);
  40.  
  41.        //Recorremos el vector para verificar el cambio de valor
  42.        for(int i=0;i<vector.length;i++)
  43.        {
  44.            System.out.print(" "+vector[i]);//Mostramos los valores
  45.        }
  46.    }
  47.  

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
  1. 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
  1.  
  2.        String[] vector = { "a","b","c","d","e" };
  3. List<String> lista = Arrays.asList(vector);
  4. lista.add("z");
  5.  

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

Código
  1.  
  2.        //Declaramos y Construimos al vector
  3.        String vector[]= {"a","b","c","d","e"};
  4.  
  5.        //Cabecera
  6.        System.out.print("***************************************\n");
  7.        System.out.print("************ Clase Arrays *************\n");
  8.        System.out.print("***************************************\n\n");
  9.        System.out.println("Valores ");
  10.        System.out.println("-------\n");
  11.  
  12.        //Recorremos el vector para Mostrarlo
  13.        for(int i=0;i<vector.length;i++)
  14.        {
  15.            System.out.print(" "+vector[i]);//Mostramos los valores
  16.        }
  17.        //Metodos Static asList de la Clase Arrays
  18.        //SubCabecera
  19.        System.out.print("\n\nasList\n");
  20.        System.out.print("-------\n");
  21.  
  22.        //Creamos la lista
  23.        List<String> lista= Arrays.asList(vector);
  24.        System.out.println(lista);
  25.  
  26.        //modificamos un valor del vector
  27.        vector[1]="z";
  28.        System.out.println(lista);
  29.        //modificamos un valor del vector
  30.        vector[4]="x";
  31.        System.out.println(lista)
  32.  
  33.  

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


« Última modificación: 24 Septiembre 2012, 07:06 am por horny3 » En línea

Observo, analizo y callo mientras me voy decepcionando en silencio.
Páginas: [1] Ir Arriba Respuesta Imprimir 

Ir a:  

WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines