Guía resumida de Java

Operadores que operan y asignan

Los operadores opera-asignan utilizados en java son los siguientes:

Operadores que operan y asignan.

Operador Uso
+= Realiza la suma y asigna el resultado.
-= Realiza la resta y asigna el resultado.
*= Hace la multiplicación y asigna el resultado.
/= Divide y hace asignación.
%= Realiza el módulo y asigna.
&= |= ^= Realiza a nivel de bits la operación y asigna el resultado.
=<< =>> =>>> Desplaza bits y asigna.

Estos operadores se utilizan mucho en Java, ya que ayudan a reducir considerablemente

el código de los programas haciendo que ocupen menos espacio en la memoria.

Ejemplos de operadores que operan y asignan el

resultado.
Declaramos e inicializamos dos variables:

int a = 3, b = 4;

a += b equivale a la expresión a = a + b; Por tanto asignamos a "a" el

valor 7 resultado de la suma. a = 7.

El resto de operandos se aplican igual, salvo los de nivel de bits, que tendremos que hacer
primero la conversión, tal y como vimos en la página anterior y después el cálculo de la
operación y la asignación del resultado.

Tipos de Cash.
 ¿Qué es un cash en java?
 Cash Implícito.
 Cash Explícito.

¿Qué es un cash en java?

Un cash es una conversión de los tipos declarados de las variables. Es muy frecuente en
Java cambiar el tipo de una variable, para transformarla en otra variable de otro tipo. Para
ello hay que aplicar un cash. Ahora bien ya vimos en la página dedicada a las variables,
que cada tipo ocupa un espacio determinado o tamaño en la memoria, por tanto el tipo de
cash aplicado, puede ser Implícito cuando pretendemos cambiar un tipo de variable de
menor tamaño a uno de mayor tamaño o Explícito en caso contrario.

Cash implícito
En el caso de Cash Implícito., Java nos resuelve el problema, ya que al ser una
conversión de un tipo de variable de menor tamaño a uno de mayor tamaño, esto se realiza
sin pérdida de datos y de forma automática por Java.

Ejemplo

// Declaramos e inicializamos dos variables de distintos tipos:

int var1=14;
float var2;

// Asignamos la variable "var1" a "var2"

var2 = var1;

// al ser una asignación de una variable tipo int a una tipo float que reserva mayor tamaño
de memoria, no hace falta aplicar ningún "cash", java se encarga de hacerlo de manera
implícita y la variable var2 añadiría el coma flotante, resultando:
var2 == 14.0

Cash explícito
En el caso de Cash Explícito., Java no resuelve el problema, ya que al ser una conversión
de un tipo de variable de mayor tamaño a uno de menor tamaño, hay una pérdida de datos,
por tanto debemos aplicar el correspondiente cash para que java sepa cómo actuar.

Ejemplo:

// Declaramos e inicializamos dos variables de distintos tipos:

int var1;
float var2=25.6;

// Asignamos la variable "var2" a "var1"

var1 = (int) var2;

// Al ser una asignación de una variable tipo float a una tipo int que reserva menor tamaño
de memoria, hay que aplicar un "cash", resultando:
var1 == 25 // Solo se conserva la parte entera del número, desechando la decimal.
Condicional switch.
El condicional swich es una sentencia que nos permite al igual que la sentencia if else,
tratar esos casos donde se deban evaluar varias condiciones, pero a diferencia de if else la
sintaxis empleada es más clara. Lo único es que el resultado de la condición o expresión
evaluada debe ser un entero. (A partir de Java 7, se permiten resultados tipo String) La
sintaxis empleada es la siguiente:

switch ( ExprPrincipal ) {
case Expr1:
Sentencias;
case Expr2:
Sentencias;
case Expr3:
Sentencias;
case Expr4:
Sentencias;
case Expr5:
Sentencias;
default :
Sentencias;
}

He aquí un ejemplo para ver su funcionamiento:

Tenemos dos variables declaradas e inicializadas:

int a = 10;
int b = 14;

Aplicamos la instrucción switch ():

switch ( b - a ) {
case 1:
System. out.println ("El resultado está en el 'primer case'.");
case 2:
System. out.println ("El resultado está en el 'segundo case'.");
case 4:
System.out.println ("El resultado está en el 'tercer case'.");

Este ejemplo es muy sencillo de entender. Se han declarado dos variables tipo int a las
que hemos asignado unos valores. Después se ha utilizado como expresión la diferencia
de "b" menos "a", que dará un valor determinado, en concreto da como resultado "4",
aunque bien podríamos no saberlo y dejar a la instrucción que busque entre los "case" a
ver si coincide alguno (Esta es otra forma de utilizarlo.). Por otro lado, hemos incluido en
cada case una simple sentencia, que permite ver por consola una cadena de texto. Tras la
ejecución del programa, el único case que coincide con el resultado "4" es el tercer case,
“case 4:”. Por tanto, se ejecutaría el código que este tenga en su bloque, que sería:
System.out. println ("El resultado está en el 'tercer case'.");

Pero, que ocurriría si tras el último case tuviésemos otro case, por ejemplo:

Tenemos dos variables declaradas e inicializadas:

int a = 10;
int b = 14;

Aplicamos la instrucción switch():

switch ( b - a ) {
case 1:
System.out.println ("El resultado está en el 'primer case'.");
case 2 :
System.out.println ("El resultado está en el 'segundo case'.");
case 4 :
System.out.println ("El resultado está en el 'tercer case'.");
case 5 :
System.out.println ("El resultado está en el 'cuarto case'.");

el resultado sería que se ejecutarían la sentencia del tercer case, case 4: y la del case o
cases que le siguiesen, en este caso case 5:

System.out.println ("El resultado está en el 'tercer case'.");

System.out.println ("El resultado está en el 'cuarto case'.");

En principio, esto podría considerarse como un error, pero no lo es tanto, ya que

dependiendo del resultado en consola buscado, nos puede interesar que a partir de cierto
case, se ejecuten las sentencias de todos los case que le sigan. En cualquier caso, podemos
evitar que esto ocurra, es decir, que solo se ejecute el case que realmente coincida con el
resultado de la primera expresión o condición del switch, añadiendo la instrucción break;
al final de la última instrucción del bloque de cada case, de esta manera:

Tenemos dos variables declaradas e inicializadas:

int a = 10;
int b = 14;

Aplicamos la instrucción switch ():

switch ( b - a ) {
case 1 :
System.out.println ("El resultado está en el 'primer case'.");
break;
case 2 :
System.out.println ("El resultado está en el 'segundo case'.");
break;
 case 4 :
System.out.println ("El resultado está en el 'tercer case'.");
break;
case 5 :
System.out.println ("El resultado está en el 'cuarto case'.");

De esta manera aseguramos de que solo se ejecute las sentencias del case que realmente
coincide con el resultado de la condición del switch. En el último case no es necesario
poner un break.

Como pueden observar dentro de esa cadena aparece un marcado con comillas simples
('): las cadenas 'primer case', 'segundo case'...Esto es con la intención de que veamos cómo
debemos incluir el texto dentro o junto a otra cadena de texto, para que el compilador de
java no muestre error de compilación.

Hay varias formas posibles de incluir un texto entrecomillado dentro de otro texto, estas
son:

 System.out.println ("El resultado está en el 'primer case'.");

// Con comillas simples.
 System.out.println ("El resultado está en el" + " 'primer case'. " ");
// Utilizando el operador de concatenación + y envolviendo las comillas
simples en otras dobles, lo cual no tiene sentido práctico alguno, pero nos ha
servido para conocer otra forma de utilizar el operador +, para concatenar
cadenas de texto.

Si lo que se desea es presentar texto entre comillas dobles (".......") y que estas aparezcan
en consola, también hay varias formas:

Declaramos tres variables una de tipo char:

int a = 10;
int b = 14;
char c = ' " '; // Incluimos el caracter que queremos presentar, entre comillas
simples.

Aplicamos la instrucción switch ():

switch ( b - a ) {
case 1:
System. out.println ("El resultado está en el"+c+ 'primer case'+c+".");
case 2:
System.out.println ("El resultado está en el"+c+ 'segundo case'+c+".");
case 4:
System.out.println ("El resultado está en el"+c+ 'tercer case'+c+".");

Otra forma de hacerlo sería así:

Declaramos tres variables todas de tipo int:

int a = 10;
int b = 14;
int c = 34; // 34 es el valor decimal del caracter (").

Aplicamos la instrucción switch ():

switch ( b - a ) {
case 1:
System.out.println ("El resultado está en el"+(char)c +"primer case"+
(char)c +".");
case 2:
System.out.println ("El resultado está en el"+(char)c +"segundo case"+
(char)c+".");
case 4:
System.out.println ("El resultado está en el"+ (char)c +"tercer
case"+(char)c +".");
// Aplicando un "(cash)" a la variable tipo int "c" para convertirla en tipo "char".
}

Esto es solo una pequeña forma del trabajo con cadenas, para familiarizarse con las
mismas.

En java hay tres tipos de bucles diferentes:

 Bucle while
 Bucle do while
 Bucle for

Bucle while
El bucle while evalúa una condición y tras esta, puede o no, ejecutar el código o
instrucciones de su bloque un número determinado de veces que oscila de 0 a infinitas
veces, dependiendo de si el bucle está controlado o no por una sentencia condicional o
condición.

La sintaxis de esta sentencia es:

while (condición)
{
sentencias o instrucciones
}

El esquema de funcionamiento de esta instrucción es como el siguiente:

Si se cumple la condición se ejecutan las instrucciones de su bloque y vuelve a evaluarse
la condición, si la condición no se cumple las instrucciones no se ejecutan ni una sola vez,
devolviendo el mando al curso del programa y a la primera instrucción que haya después
del bucle while.

Bucle for
El bucle for ejecuta el bloque de instrucciones controladas por un contador, mientras se
cumpla una determinada condición hasta que la condición evaluada retorne false,
momento en el cual se saldrá del bucle for

La sintaxis de esta sentencia es:

for ( Inic. de variables. ;condición; increm./decrem. ) {

sentencias o instrucciones;
}

Este es el aspecto normal de un bucle for:

for ( i = 1 ; i <= 10 ; i++ ) {

sentencias o instrucciones;
}

El esquema de funcionamiento de esta instrucción es como el siguiente:

Primero se inicializa la variable/s del bucle, esto solo se realiza una vez al principio del
bucle. Después se evalúa la condición, si esta resulta true se ejecutan las sentencias del
bucle y posteriormente se incrementa o decrementa el valor de la variable, dependiendo
del operador que se haya utilizado, en este caso hemos utilizado el operador de incremento
( +1 ) i++. Después se retorna a evaluar la condición de nuevo. Si al principio de evaluar
la condición tras la inicialización de variables o en cualquier otro momento de la
ejecución del bucle for, la misma hubiera generado un resultado false, no se ejecutarían
ninguna sentencia o instrucción del bucle for más, devolviendo el control al flujo del
programa y a la siguiente instrucción que corresponda tras el bucle for.

Por último decir que los bucles pueden anidarse, es decir, incluir bucles unos dentro de
otros, para conseguir resultados determinados:

for ( int a = 1 ; a <= 10 ; a++ ) {

for (int b = 1 ; b <= 10 ; b++ ) {
for (int c = 1 ; c <= 10 ; c++ ) {
for ( int d= 1 ; d <= 10 ; d++ ) {
sentencias o instrucciones;
}
}
}
}

Bucle do while
El bucle do while ejecuta el bloque de instrucciones del do y después evalúa la condición
de la instrucción while. Esta hará que las instrucciones del bloque do sigan o no sigan
ejecutándose. El bucle do while asegura que el bloque de instrucciones controladas por el
do, se ejecuten al menos una vez.

La sintaxis de esta estructura de control es:

do
{
sentencias o instrucciones
} while (condición) ;

El while del bucle do while a diferencia del bucle while debe acabar en punto y coma (;),
es importante no olvidarlo. El esquema de funcionamiento de esta instrucción es como el
siguiente:

las instrucciones del do se ejecutan primero, después se evalúa la condición del while. Si
esta resulta true, vuelven a ejecutarse las instrucciones del bloque do y repite mismo
proceso hasta que la condición del while resulte false, momento en que el programa saldrá
del bucle y seguirá su curso después de él.

Consola, println
El significado de esta sentencia es: Utilizamos el método println, llamado por el objeto
out, que pertenece a la clase System, para mostrar una información en la consola. En caso
de utilizar "Netbeans", dicha información aparece en un apartado del mismo programa.

Entrada de Datos
Java está diseñado para trabajar bajo Entorno Gráfico, aunque es posible introducir datos
con el teclado en un programa que los solicite y que estos aparezcan por consola aplicando
los métodos de una clase, que anteriormente hemos creado y que situaremos, bien dentro
de la misma clase que contiene al método main, ó tal y como es lo habitual y
recomendable, situaremos aquella clase en un fichero aparte, en el mismo paquete donde
se encuentre la clase que contiene el programa principal.

Como de momento no hemos tratado el tema de las clases, ni métodos, ni paquetes, etc.,
nos limitaremos a copiar la clase, dentro de la clase que contiene el programa principal,
para poder realizar la entrada de datos.

El código que tiene la siguiente clase, que después se pondrá en el cuerpo de la clase del
programa principal. Dicha clase que he llamado EntDatos, tiene el siguiente código:

import java.io.*;

public class EntDatos {

public static String inicial ( ) {
String datointroducido = "" ;
try {
InputStreamReader flujo= new InputStreamReader
(System.in ); // Definimos un flujo de caracteres de entrada.

BufferedReader teclado = new BufferedReader ( flujo );

// Creamos un objeto de esta clase que almacenará la información en un
bufer.
datointroducido = teclado .readLine();
// Introducimos la entrada y la asignamos a una variable.
} catch (IOException e){
System.err .print ( "Error: " + e.getMessage ( )
);
}
return datointroducido ;
}
//--------------------------------------------------------------------
----
public static int entero( ) {
try
{
return Integer.parseInt( inicial( ) );
} catch ( NumberFormatException e ) {
return Integer. MIN_VALUE; // valor más pequeño.
}
}
//--------------------------------------------------------------------
----
public static double real( ) {
try
{
return Double.parseDouble ( inicial( ) );
} catch ( NumberFormatException e ) {
return Double. NaN; // No es un número.
}
}
//--------------------------------------------------------------------
----
public static String cadena() {
return inicial( );
}
//--------------------------------------------------------------------
----
 static char caracter() ( ) {
String valor= inicial();
return valor.charAt(0);
}
}

Los ARRAY

Array unidimensionales

Declaración de una Matriz

Para declarar una matriz, tenemos que especificar el tipo de dato que tendrán los
elementos de la misma y utilizar los [ ], símbolo que se utiliza para diferenciarlo de una
declaración de variable normal. La declaración de una matriz se puede hacer de varias
maneras:

<Tipo de dato> <nombre> [ ] ;

ó
<Tipo de dato> [ ] <nombre> ;
int notas [ ] ;
ó
int [ ] notas ;

Tamaño de una Matriz

El tamaño de una matriz, sirve una vez declarada, para establecer el número de
elementos que tendrá dicha matriz y reservar en memoria el respectivo espacio que se
necesitará a la hora de introducir valores o datos en la misma, es decir, crear la matriz
propiamente dicho.

Hay dos maneras de crear una matriz y establecer el tamaño de la misma:

Con new, sin asignar valores.

 <nombre> = new <Tipo de dato> [<Tamaño>];
notas = new int [ 7 ] ;

Sin new, asignando valores.

int notas [ ] = { 10, 12, 20, 32, 7, 6, 15 } ;

En el primer caso hemos asignado a la matriz anteriormente declarada "notas" un Tamaño

para albergar 7 elementos, por tanto el índice de la matriz irá de "0"...a..."6".

En el segundo caso, hemos creado la matriz "notas" de tipo int y hemos asignado a la
misma "7" valores, por tanto hemos creado "7 elementos" automáticamente. Por supuesto
al igual que en el caso anterior, a cada elemento le corresponde su respectivo índice
(0...6), que nos dará total acceso al dato guardado en aquel.

A veces en los programas que se crean, necesitamos expresar de alguna manera, el tamaño
o elementos que tiene una matriz que utilicemos, incluso cuando sabemos perfectamente
el tamaño de la misma, al haberla declarado y creado anteriormente. Para ello en Java
disponemos de la palabra reservada length, que devuelve un entero, con el número de
elementos que tiene dicha matriz. Se utiliza de la siguiente manera:

int notas [ ] = { 10, 12, 20, 32, 7, 6, 15 } ;

System.out.println ("La matriz notas tiene un tamaño de "+ notas.length +"
elementos." ) ;

resultando en consola: La matriz notas tiene un tamaño de 7 elementos.

Declaración y asignación de tamaño a una matriz en una

sola sentencia
A veces nos veamos en la necesidad de declarar una matriz unidimensional y crearla con
un determinado tamaño o número de elementos, dentro de algún bloque de código, para
ello java permite realizar lo anterior en una sola sentencia:

int [ ] notas = new int [ 7 ] ;

Asignar valores a los elementos de una Matriz.

Para asignar valores a un elemento o varios de una matriz ya declarada y con un
tamaño determinado, hay que utilizar la siguiente expresión:
 <nombre> [ índice ] = valor ;
notas [ 2 ] = 10 ;

Con esta sentencia hemos asignado el valor "10" al elemento de la matriz con índice 2.

Por ejemplo cogiendo los valores que hemos asignado antes a la matriz notas:

int notas [ ] = {10, 12, 20, 32, 7, 6, 15 } ;

Los valores tras aplicar la sentencia:

notas [2] = 10;

Quedarían así al visualizar la matriz completa (Asunto que aún no hemos tratado):

10, 12,10, 32, 7, 6, 15

Se puede asignar una variable a un elemento determinado de una matriz, siempre y

cuando el valor de la variable sea del mismo tipo que el tipo de dato declarado en la
matriz.

int a =10;
notas [ 2 ] = a ;

double a =10.3;
notas [ 2 ] = ( int ) a ; // Aplicando un cast.

Recorrer los elementos de una matriz y ver su contenido

Para ver los datos de un elemento específico de una matriz, ya hemos dicho la forma de
hacerlo, pero ¿Cómo podemos visualizar el contenido de más de un elemento, incluso de
toda la matriz?. La respuesta es, utilizando un bucle for:

int limSup = notas.length -1;

for ( int i = 0 ; i <= limSup ; i++ ) {

System.out. println ( notas [ i ] );
}

Matrices multidimensionales
Con esta sentencia hemos creado una matriz multidimensional de dos dimensiones. El
primer corchete [2], indica el número de matrices de una sola dimensión o
unidimensionales que hay, por tanto su tipo de dato es int [ ]. En este caso hay 2 matrices
unidimensionales. El segundo corchete [3], indica el número de elementos que tiene cada
una de las dos matrices unidimensionales anteriores y su tipo de dato es int. Los índices
de esta matriz creada quedarían de la siguiente manera:

Aunque quizás se entiende mejor el concepto de matriz multidimensional, si lo vemos

en forma de filas y columnas:

Asignar valores a los elementos de una matriz

multidimensional
Para asignar valores a una matriz multidimensional se actúa de la misma manera que
en las matrices unidimensionales, salvo que ahora serán varios los índices que
intervengan. Una vez que tenemos la matriz creada, por ejemplo la matriz "notas",
actuaremos de la siguiente manera para acceder a los elementos:

notas [ 0 ] [ 0 ] = 10 ;
notas [ 1 ] [ 2 ] = 9 ;

La primera sentencia asigna el valor "10" al elemento de la matriz unidimensional (col0)

con índice "0", que esta referenciado por la matriz (fila-0). La segunda sentencia hace lo
propio asignando el valor "9" al elemento situado en la matriz unidimensional (col2),
referenciado por la matriz (fila-1).
Java inicializa por defecto los elementos vacíos de una matriz a "0" ó, a "null" si es una
matriz de objetos.

Recorrer los elementos de una matriz para asignar

valores o ver su contenido
Al igual que con las matrices simples o unidimensionales, también podemos emplear
bucles for para asignar o ver los datos de una matriz multidimensional:

Asignar datos a una matriz multidimensional:

int lim_0 = notas [ 0 ]. length ;

int lim_1 = notas [ 1 ]. length ;

for ( int k = 0 ; k < lim_0 ; k++ ) {

for ( int l = 0 ; l < lim_1 ; l++ ) {
notas [ k ] [ l ] = EntDatos. entero( );
}
}

Ver datos de una matriz multidimensional:

int lim_0 = notas [ 0 ]. length ;

int lim_1 = notas [ 1 ]. length ;

for ( int k = 0 ; k < lim_0 ; k++ ) {

for ( int l = 0 ; l < lim_1 ; l++ ) {
System.out. println ( notas [ k ] [ l ] ) ;
}
}

Como se puede observar se ha declarado dos variables lim_0 y lim_1, para saber el
tamaño de cada matriz unidimensional y establecer límites a los bucles. Las variables "k"
y "l" representan las filas y las columnas de la matriz bidimensional.

Para asignar datos a la matriz se puede utilizar la clase EntDatos y su método entero( )
para introducir números enteros por teclado. Esta clase debe de estar en el mismo paquete,
donde utilicemos la llamada a la misma, o en su defecto (no aconsejable) en la clase donde
se sitúe el programa principal (contiene el método main( )) desde donde efectuemos la
llamada al método de la clase EntDatos.
Matrices tridimensionales
Hasta ahora en esta página nos hemos centrado en trabajar con una matriz de dos
dimensiones o bidimensional, compuesta de una dimensión filas (eje y) y una dimensión
columnas (eje x). Para crear una matriz tridimensional hay que añadir un eje más (eje
Z) a la síntexis de la tabla o matriz:

int [ ] [ ] [ ] cubo = new int [ 3 ] [ 3 ] [ 3 ] ;

La tabla podría representarse con el siguiente dibujo, donde podemos ver los índices
que tendrían cada elemento de la misma:

Para asignar valores a este tipo de matriz, se haría así, para un ejemplo:

cubo [ 0 ] [ 0 ] [ 0 ] = 10 ;
cubo [ 2 ] [ 2 ] [ 0 ] = 20 ;
cubo [ 1 ] [ 2 ] [ 2 ] = 5 ;

Se puede utilizar, también bucles anidados for para asignar y ver los valores de la matriz
tridimensional después:

Asignar datos a una matriz tridimensional:

int lim_0 = cubo [ 0 ]. length ;
int lim_1 = cubo [ 1 ]. length ;
int lim_2 = cubo [ 2 ]. length ;

for ( int y = 0 ; y < lim_0 ; y++ ) {

for ( int x = 0 ; x < lim_1 ; x++ ) {
for ( int z = 0 ; z < lim_2 ; z++ ) {
notas [ y ] [ x ] [ z ] = EntDatos.entero( ) ;
}
}
}

Ver los datos de una matriz tridimensional:

int lim_0 = cubo [ 0 ]. length ;

int lim_1 = cubo [ 1 ]. length ;
int lim_2 = cubo [ 2 ]. length ;

for ( int y = 0 ; y < lim_0 ; y++ ) {

for ( int x = 0 ; x < lim_1 ; x++ ) {
for ( int z = 0 ; z < lim_2 ; z++ ) {
System.out.println ( cubo [ y ] [ x ] [ z ] ) ;
}
}
}

Uso de la utilidad Arrays

Para trabajar con
paquete java.util.Arrays

Para acceder a estos métodos, debemos importar el paquete java.util.Arrays antes de la

clase.

Te indicamos el nombre, su descripción, parámetros y que devuelve.

Para ejecutar estos métodos, lo haremos de la siguiente manera

Arrays.nombre_metodo(parámetro);

Estos son los métodos:

Dato
Nombre Descripción Parámetros
devuelto
Busca un valor que le Un array y un valor. Los dos del
pasamos por parámetro, mismo tipo. Estos pueden ser un
binarySearch int
devuelve su posición. byte, char, double, float, int, long,
Debe estar ordenado. short u objecto.
 Dato
Nombre Descripción Parámetros
devuelto
Un array y la longitud. Si se pasa
del tamaño del array original, array del
Copia un array y lo
rellena los con ceros las posiciones mismo tipo
copyOf devuelve en un nuevo
sobrantes. Estos pueden ser un que se
array.
byte, char, double, float, int, long, introduce
short u objecto.
Copia un array y lo
Un array, posición origen y destino. array del
devuelve en un nuevo
Estos pueden ser un byte, char, mismo tipo
copyOfRange array. Le indicamos la
double, float, int, long, short u que se
posición de origen y de
objecto. introduce.
destino.
Indica si dos arrays son
equals Dos arrays del mismo tipo. true o false
iguales.
Un array y el valor a rellenar.
Rellena un array con un
Estos pueden ser un byte, char, No devuelve
fill valor que le indiquemos
double, float, int, long, short u nada
como parámetro.
objecto.
Un array.
Estos pueden ser un byte, char, No devuelve
sort Ordena el array.
double, float, int, long, short u nada
objecto.
Devuelve una
Muestra el contenido del Un array. Estos pueden ser un
cadena con el
toString array pasado como byte, char, double, float, int, long,
contenido del
parámetros short u object.
array.
1 import java.util.Arrays;
2 public class PruebaApp {
3
public static void main(String[] args) {
4 int num[]={8, 10, 15, 20, 21, 25, 30, 32, 40, 41};
5
6 //Devuelve un 4
7 System.out.println("Metodo binarySearch:
8 "+Arrays.binarySearch(num, 21));
//Copia el array num hasta la quinta posicion(este último no
9 incluido), devuelve un array
10 int num2[]=Arrays.copyOf(num, 4);
11
12 System.out.println("Metodo copyOf ");
13 //Lo recorremos para ver que lo realiza correctamente
14 muestraArray(num2);
15
16devuelve//Copia
un array
el array num de la tercera hasta la octava posicion,
17 int num3[]=Arrays.copyOfRange(num, 2, 6);
18 System.out.println("Metodo copyOfRange");
19 muestraArray(num3);
20
21 //Compara si num1 y num2 no son iguales
System.out.println("Metodo equals: "+Arrays.equals(num,
22num2));
23
24 System.out.println("Metodo fill");
25 Arrays.fill(num3, 5);
26 muestraArray(num3);
27
28 System.out.println("Metodo toString");
System.out.println(Arrays.toString(num));
29 }
30
31 public static void muestraArray(int num[]){
32
33 for (int i=0;i<num.length;i++){
34 System.out.println(num[i]);
35 }
36
}
37}
38
39