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.
Nota:Utilisaremos sta clase para ingresar datos x teclado..! si es necesaio tambien tendremos q importarla
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Leer
{
{
try
{
// Definir un flujo de caracteres de entrada: flujoE
// Leer. La entrada finaliza al pulsar la tecla Entrar
sdato = flujoE.readLine();
}
{
System.
err.
println("Error: " + e.
getMessage()); }
return sdato; // devolver el dato tecleado
}
public static short datoShort()
{
try
{
return Short.
parseShort(dato
()); }
{
return Short.
MIN_VALUE; // valor más pequeño }
}
public static int datoInt()
{
try
{
}
{
return Integer.
MIN_VALUE; // valor más pequeño }
}
public static long datoLong()
{
try
{
return Long.
parseLong(dato
()); }
{
return Long.
MIN_VALUE; // valor más pequeño }
}
public static float datoFloat()
{
try
{
return f.floatValue();
}
{
return Float.
NaN; // No es un Número; valor float. }
}
public static double datoDouble()
{
try
{
return d.doubleValue();
}
{
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:
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:
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 1i
= 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 1i
= 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:
//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:
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:
//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");
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:
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:
//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(". Todos los valores del vector\n"); //damos el valor "0", a todos los elementos del 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\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:
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:
//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. 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
//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.
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.
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).
//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
);
//modificamos un valor del vector
vector[1]="z";
//modificamos un valor del vector
vector[4]="x";
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
Mostrar Mensajes
