Los arrays no tienen demasiada história que explicar en un principio. Mira simplemente como funcionan y ya está. Fijate que inicializar un array es simplemente inicializar el contenedor. Aumque no haya nada dentro se puede preguntar por el numero de posiciones que alberga. Un array es en realidad una clase contenedora (por eso lo de el new() ) y lo que contiene en realidad son las referencias a los objetos que contiene, no contiene los objetos en si.
//Array.java
// inicialización y reasignacion de array
class Mitologia{}
public class TerminoArray{
public static void main(String[] args){
// array de objetos
Mitologia[] a; // referencia null
Mitologia[] b = new Mitologia[5]; // referencia null
Mitologia[] c = new Mitologia[4];
for(int i=0; i<c.length; i++){
c[i]= new Mitologia(); // ahora estan inicializadas todas las posiciones
}
Mitologia[] d = {new Mitologia(),new Mitologia(),new Mitologia()}; // inicializacion de agregados
a = new Mitologia[]{new Mitologia(),new Mitologia()}; // inicialización dinámica
System.out.println("a.length = " + a.length);
System.out.println("b.length = " + b.length);
for(int i =0; i<b.length; i++){ // las referencias internas se inicializan a nulo
System.out.println("b["+ i +"]="+b[i]);
}
System.out.println("c.length = " + c.length);
System.out.println("d.length = " + d.length);
a=d;
System.out.println("a=d; a.length" + a.length);
// ARRAYS DE DATOS PRIMITIVOS
int[] e; // referencia a nulo
int[] f = new int[5];
int[] g = new int[4];
for (int i = 0; i<g.length; i++) g[i]=i*i;
int[] h = {2,4,6,7,8};
// los primitivos dentro de un array se inicializan automaticamente a 0
for(int i =0; i<f.length;i++){
System.out.println("f["+ i +"]="+f[i]);
}
System.out.println("g.length = " + g.length);
System.out.println("h.length = " + h.length);
// ERROR DE PROGRAMACION. VARIABLE SIN INICIALIZAR
//System.out.println("e.length" + e.length);
e=h;
System.out.println("e.length = " + e.length);
e= new int[]{2,4,5,6,5,4,7,8,5,55,4};
System.out.println("e.length = " + e.length);
g=e;
System.out.println("g.length = " + g.length);
}
}
que siempre hay un pero….. fijate en lo siguiente….. Supongamos que queremos hacer una utilidad que nos permita generar arrays facilmente y que nos permita imprimirlos sin necesidad de hacer el bucle cada vez, que nos pemita hacerlo en una sóla linea. Para hacer eso tendremos que:
es un poco largo pero merece la pena que le eches un vistazo para que veas de que va esto de la programación orientada a objetos, las clases abstractas, las interfaces y demás.
Este es el abstracto para cualquier tipo de Ojeto. Aqui cabe cualquier cosa:
// net:juantxu:util:Generador.java
package net.juantxu.util;
public interface Generador{
Object siguiente();
}
Y a continuacion el abstracto para cada tipo concreto:
// net:juantxu:util:GeneradorBoolean.java
package net.juantxu.util;
public interface GeneradorBoolean{
boolean siguiente();
}
// net:juantxu:util:GeneradorByte.java
package net.juantxu.util;
public interface GeneradorByte{
byte siguiente();
}
// net:juantxu:util:GeneradorChar.java
package net.juantxu.util;
public interface GeneradorChar{
char siguiente();
}
// net:juantxu:util:GeneradorDouble.java
package net.juantxu.util;
public interface GeneradorDouble{
double siguiente();
}
// net:juantxu:util:GeneradorFloat.java
package net.juantxu.util;
public interface GeneradorFloat{
float siguiente();
}
// net:juantxu:util:GeneradorInt.java
package net.juantxu.util;
public interface GeneradorInt{
int siguiente();
}
// net:juantxu:util:GeneradorLong.java
package net.juantxu.util;
public interface GeneradorLong{
long siguiente();
}
// net:juantxu:util:GeneradorShort.java
package net.juantxu.util;
public interface GeneradorShort{
short siguiente();
}
Y por fin la implementación:
// net:juantxu:util:Arrays2.java
// un suplemento para java.util arrays. que permite funcionalidades nuevas
// permitirá escribir y rellenar arrays a traves de un "generador"
package net.juantxu.util;
import java.util.*;
public class Arrays2{
private static void comenzar( int de, int para, int longitud){ // en el libro esta equivocado, creo
if( de != 0 || para != longitud ){
System.out.print( "[" + de + ":" + para + "] ");
}
System.out.print("(");
}
private static void fin(){
System.out.println(")");
}
//----------------------------------------------------------------------------------------------------->
public static void escribir(Object[] a){
escribir(a, 0, a.length);
}
public static void escribir(String mensaje, Object[] a){
System.out.print(mensaje + " ");
escribir(a, 0, a.length);
}
public static void escribir(Object[] a, int de, int para){ // vamos a imprimir el objeto
comenzar( de, para, a.length);
for ( int i = de; i < para; i++ ){
System.out.print(a[i]);
if( i < (para - 1)){ // añadimos el separador de las comas
System.out.print(", ");
}
}
fin();
}
//----------------------------------------------------------------------------------------------------->
public static void escribir(boolean[] a){
escribir(a, 0, a.length);
}
public static void escribir(String mensaje, boolean[] a){
System.out.print(mensaje + " ");
escribir(a,0,a.length);
}
public static void escribir( boolean[] a, int de, int para){
comenzar(de, para, a.length);
for(int i = de; i < para; i++){
System.out.print(a[i]);
if (i<para-1){
System.out.print(", ");
}
}
fin();
}
//----------------------------------------------------------------------------------------------------->
public static void escribir(byte[] a){
escribir(a, 0, a.length);
}
public static void escribir(String mensaje, byte[] a){
System.out.print(mensaje + " ");
escribir(a,0,a.length);
}
public static void escribir( byte[] a, int de, int para){
comenzar(de, para, a.length);
for(int i = de; i < para; i++){
System.out.print(a[i]);
if (i<para-1){
System.out.print(", ");
}
}
fin();
}
//----------------------------------------------------------------------------------------------------->
public static void escribir(char[] a){
escribir(a, 0, a.length);
}
public static void escribir(String mensaje, char[] a){
System.out.print(mensaje + " ");
escribir(a,0,a.length);
}
public static void escribir( char[] a, int de, int para){
comenzar(de, para, a.length);
for(int i = de; i < para; i++){
System.out.print(a[i]);
if (i<para-1){
System.out.print(", ");
}
}
fin();
}
//----------------------------------------------------------------------------------------------------->
public static void escribir(short[] a){
escribir(a, 0, a.length);
}
public static void escribir(String mensaje, short[] a){
System.out.print(mensaje + " ");
escribir(a,0,a.length);
}
public static void escribir( short[] a, int de, int para){
comenzar(de, para, a.length);
for(int i = de; i < para; i++){
System.out.print(a[i]);
if (i<para-1){
System.out.print(", ");
}
}
fin();
}
//----------------------------------------------------------------------------------------------------->
public static void escribir(int[] a){
escribir(a, 0, a.length);
}
public static void escribir(String mensaje, int[] a){
System.out.print(mensaje + " ");
escribir(a,0,a.length);
}
public static void escribir( int[] a, int de, int para){
comenzar(de, para, a.length);
for(int i = de; i < para; i++){
System.out.print(a[i]);
if (i<para-1){
System.out.print(", ");
}
}
fin();
}
//----------------------------------------------------------------------------------------------------->
public static void escribir(long[] a){
escribir(a, 0, a.length);
}
public static void escribir(String mensaje, long[] a){
System.out.print(mensaje + " ");
escribir(a,0,a.length);
}
public static void escribir( long[] a, int de, int para){
comenzar(de, para, a.length);
for(int i = de; i < para; i++){
System.out.print(a[i]);
if (i<para-1){
System.out.print(", ");
}
}
fin();
}
//----------------------------------------------------------------------------------------------------->
public static void escribir(float[] a){
escribir(a, 0, a.length);
}
public static void escribir(String mensaje, float[] a){
System.out.print(mensaje + " ");
escribir(a,0,a.length);
}
public static void escribir( float[] a, int de, int para){
comenzar(de, para, a.length);
for(int i = de; i < para; i++){
System.out.print(a[i]);
if (i<para-1){
System.out.print(", ");
}
}
fin();
}
//----------------------------------------------------------------------------------------------------->
public static void escribir(double[] a){
escribir(a, 0, a.length);
}
public static void escribir(String mensaje, double[] a){
System.out.print(mensaje + " ");
escribir(a,0,a.length);
}
public static void escribir( double[] a, int de, int para){
comenzar(de, para, a.length);
for(int i = de; i < para; i++){
System.out.print(a[i]);
if (i<para-1){
System.out.print(", ");
}
}
fin();
}
//----------------------------------------------------------------------------------------------------->
// rellenar los arrays
//----------------------------------------------------------------------------------------------------->
public static void rellenar(Object[] a, Generador gen){
rellenar(a, 0, a.length, gen);
}
public static void rellenar(Object[] a, int de, int para, Generador gen){
for (int i=de; i < para; i++){
a[i] = gen.siguiente();
}
}
//----------------------------------------------------------------------------------------------------->
public static void rellenar(boolean[] a, GeneradorBoolean gen){
rellenar(a, 0, a.length, gen);
}
public static void rellenar(boolean[] a, int de, int para, GeneradorBoolean gen){
for (int i=de; i < para; i++){
a[i] = gen.siguiente();
}
}
//----------------------------------------------------------------------------------------------------->
public static void rellenar(byte[] a, GeneradorByte gen){
rellenar(a, 0, a.length, gen);
}
public static void rellenar(byte[] a, int de, int para, GeneradorByte gen){
for (int i=de; i < para; i++){
a[i] = gen.siguiente();
}
}
//----------------------------------------------------------------------------------------------------->
public static void rellenar(char[] a, GeneradorChar gen){
rellenar(a, 0, a.length, gen);
}
public static void rellenar(char[] a, int de, int para, GeneradorChar gen){
for (int i=de; i < para; i++){
a[i] = gen.siguiente();
}
}
//----------------------------------------------------------------------------------------------------->
public static void rellenar(short[] a, GeneradorShort gen){
rellenar(a, 0, a.length, gen);
}
public static void rellenar(short[] a, int de, int para, GeneradorShort gen){
for (int i=de; i < para; i++){
a[i] = gen.siguiente();
}
}
//----------------------------------------------------------------------------------------------------->
public static void rellenar(int[] a, GeneradorInt gen){
rellenar(a, 0, a.length, gen);
}
public static void rellenar(int[] a, int de, int para, GeneradorInt gen){
for (int i=de; i < para; i++){
a[i] = gen.siguiente();
}
}
//----------------------------------------------------------------------------------------------------->
public static void rellenar(long[] a, GeneradorLong gen){
rellenar(a, 0, a.length, gen);
}
public static void rellenar(long[] a, int de, int para, GeneradorLong gen){
for (int i=de; i < para; i++){
a[i] = gen.siguiente();
}
}
//----------------------------------------------------------------------------------------------------->
public static void rellenar(float[] a, GeneradorFloat gen){
rellenar(a, 0, a.length, gen);
}
public static void rellenar(float[] a, int de, int para, GeneradorFloat gen){
for (int i=de; i < para; i++){
a[i] = gen.siguiente();
}
}
//----------------------------------------------------------------------------------------------------->
public static void rellenar(double[] a, GeneradorDouble gen){
rellenar(a, 0, a.length, gen);
}
public static void rellenar(double[] a, int de, int para, GeneradorDouble gen){
for (int i=de; i < para; i++){
a[i] = gen.siguiente();
}
}
//----------------------------------------------------------------------------------------------------->
// y ahora por fin los generadores
//----------------------------------------------------------------------------------------------------->
private static Random r = new Random();
static String fuente = "ABCDEFGHYJKLMNÑOPQRSTUVWXYZ" +
"abcdefghijklmnñopqrstuvwxyz";
static char[] fuenteArray = fuente.toCharArray();
//----------------------------------------------------------------------------------------------------->
public static class GeneradorBooleanAleatorio implements GeneradorBoolean{
public boolean siguiente(){
return r.nextBoolean();
}
}
//----------------------------------------------------------------------------------------------------->
public static class GeneradorByteAleatorio implements GeneradorByte{
public byte siguiente(){
return (byte)r.nextInt();
}
}
//----------------------------------------------------------------------------------------------------->
public static class GeneradorCharAleatorio implements GeneradorChar{
public char siguiente(){
int pos = r.nextInt(fuenteArray.length); // genero una posicion aleatoria enter la cantidad del array
return fuenteArray[pos];
}
}
//----------------------------------------------------------------------------------------------------->
public static class GeneradorStringAleatorio implements Generador{
private int longitud;
private GeneradorCharAleatorio cg = new GeneradorCharAleatorio(); // me construyo un generador de caracteres
public GeneradorStringAleatorio(int lngtd){
longitud = lngtd;
}
public Object siguiente(){
char[] fug = new char[longitud];
for (int i = 0; i< longitud; i++){
fug[i]= cg.siguiente();
}
return new String(fug);
}
}
//----------------------------------------------------------------------------------------------------->
public static class GeneradorShortAleatorio implements GeneradorShort{
public short siguiente(){
return (short)r.nextInt();
}
}
//----------------------------------------------------------------------------------------------------->
public static class GeneradorIntAleatorio implements GeneradorInt{
private int mod = 1000;
public GeneradorIntAleatorio(){}
public GeneradorIntAleatorio(int modulo){
mod= modulo;
}
public int siguiente(){
return r.nextInt(mod);
}
}
//----------------------------------------------------------------------------------------------------->
public static class GeneradorLongAleatorio implements GeneradorLong{
public long siguiente(){
return r.nextLong();
}
}
//----------------------------------------------------------------------------------------------------->
public static class GeneradorFloatAleatorio implements GeneradorFloat{
public float siguiente(){
return r.nextFloat();
}
}
//----------------------------------------------------------------------------------------------------->
public static class GeneradorDoubleAleatorio implements GeneradorDouble{
public double siguiente(){
return r.nextDouble();
}
}
}
Fijate que lo primero que he hecho es cenerar la interface para cada tipo de datos. Aunque tedioso es necesario dado que hay que especificar que tipo de dato devuelve la interfaz. son el Generador.java, GeneradorBoolean.java, GeneradorByte.java, … GeneradorDouble.java. Ellos són sólo interfaces dado que me puede interesar implementarlos en cada momento de una forma distinta. Me puede interesar implementarlos para que generen arrays con valores aleatorios, como es el caso. O con valores secuenciales, o con valores iguales, o de cualquier manera.
Tras tener las interfaces que me darán el siguiente valor a introducir ya puedo implementar Array2 que es la utilidad que yo quería hacer. Primero implemento lo mas sencillo…. Imprimirlos, escribirlos, la primera parte de Array2. Para escribirlos la cabecera será siempre igual y el fin tambien comenzar() y fin(). Y en medio está el bucle que escribe todos los valores.
Pero…. me puede interesar escribir todo el array, o escribir solo ciertos valores, o escribirlos con un mensaje inicial. Por eso exixte la sobrecarga de métodos escribir(). Tengo varios escribir en funcion de como lo quiera escribir(). Y…. otra vez mas, hay que hacerlo para cada tipo de objeto. Un poco pesado pero bueno.
A continuación escribo los métodos que me permitirán rellenar los arrays. Como que … otra vez no se si quiero rellenarlo todo o quiero rellenar sólo unos cuantos valores vuelvo a hacer sobrecarga de métodos. Así escribo uno en el que recibe como parámetros el array a rellenar[], el primer valor a rellenar (de) y el último valor a rellenar (para) y el generador de valores. Este es el método principal. Luego existe el superpuesto que es el del caso de que lo quiera rellenar todo. Por lo tanto recibo sólo el array y el generador. Este método tan sólo vuelve a hacer la llamada al método rellenar (el inicial) con los valores apropiados.(array, posicion 0, posicion final del array y generador).
Por último estan los generadores. Los arrays se tienen que llenar con algo, y ese algo son los generadores de valores. Para eso habíamos creado todas esas interfaces al principio. Para implementarlas ahora. Como que quiero rellenarlos con valores aleatorio llamo a los generadores Generador_TIPO_DE_DATO_Aleatorio para que me sea fácil de detectar, le digo que implementa la interfaz Generador_TIPO_DE_DATO determinada y escribo el código pertinente. Y… se acabó.
Quieres probarlo? pues aquí te dejo una clase que lo usa:
//PruebaArrays2.java
// probando y demostrando las utilidades de Array2.java
import net.juantxu.util.*;
public class PruebaArrays2{
public static void main(String[] args){
int tamano = 6;
// recogemos argumentos
if(args.length != 0 ){ tamano= Integer.parseInt(args[0]); } // cojo la clase envoltorio Integer para poder hacer el parseint
boolean[] a1 = new boolean[tamano];
byte[] a2 = new byte[tamano];
char[] a3 = new char[tamano];
short[] a4 = new short[tamano];
int[] a5 = new int[tamano];
long[] a6 = new long[tamano];
float[] a7 = new float[tamano];
double[] a8 = new double[tamano];
String[] a9 = new String[tamano];
Arrays2.rellenar(a1, new Arrays2.GeneradorBooleanAleatorio());
Arrays2.escribir(a1);
Arrays2.escribir("a1 :=", a1);
Arrays2.escribir(a1, tamano/3, tamano/3 + tamano/3 );
//------------------------------------------------------------------------->
Arrays2.rellenar(a2, new Arrays2.GeneradorByteAleatorio());
Arrays2.escribir(a2);
Arrays2.escribir("a2 :=", a2);
Arrays2.escribir(a2, tamano/3, tamano/3 + tamano/3 );
//------------------------------------------------------------------------->
Arrays2.rellenar(a3, new Arrays2.GeneradorCharAleatorio());
Arrays2.escribir(a3);
Arrays2.escribir("a3 :=", a3);
Arrays2.escribir(a3, tamano/3, tamano/3 + tamano/3 );
//------------------------------------------------------------------------->
Arrays2.rellenar(a4, new Arrays2.GeneradorShortAleatorio());
Arrays2.escribir(a4);
Arrays2.escribir("a4 :=", a4);
Arrays2.escribir(a4, tamano/3, tamano/3 + tamano/3 );
//------------------------------------------------------------------------->
Arrays2.rellenar(a5, new Arrays2.GeneradorIntAleatorio());
Arrays2.escribir(a5);
Arrays2.escribir("a5 :=", a5);
Arrays2.escribir(a5, tamano/3, tamano/3 + tamano/3 );
//------------------------------------------------------------------------->
Arrays2.rellenar(a6, new Arrays2.GeneradorLongAleatorio());
Arrays2.escribir(a6);
Arrays2.escribir("a6 :=", a6);
Arrays2.escribir(a6, tamano/3, tamano/3 + tamano/3 );
//------------------------------------------------------------------------->
Arrays2.rellenar(a7, new Arrays2.GeneradorFloatAleatorio());
Arrays2.escribir(a7);
Arrays2.escribir("a7 :=", a7);
Arrays2.escribir(a7, tamano/3, tamano/3 + tamano/3 );
//------------------------------------------------------------------------->
Arrays2.rellenar(a8, new Arrays2.GeneradorDoubleAleatorio());
Arrays2.escribir(a8);
Arrays2.escribir("a8 :=", a8);
Arrays2.escribir(a8, tamano/3, tamano/3 + tamano/3 );
//------------------------------------------------------------------------->
Arrays2.rellenar(a9, new Arrays2.GeneradorStringAleatorio(9));
Arrays2.escribir(a9);
Arrays2.escribir("a9 :=", a9);
Arrays2.escribir(a9, tamano/3, tamano/3 + tamano/3 );
}
}