RSS

Asignaciones – Arrays

08 Oct

Un array es un objeto que nos permite guardar varios elementos de un mismo tipo. Un array puede guardar valores de tipo primitivo o de tipo de referencia, pero el array siempre será un objeto y como tal se almacena en la memoria dinámica, el Heap.

Los arrays pueden ser unidimensionales (vectores) o multidimensionales (matrices).

En la imagen superior tenemos un ejemplo de un array unidimensional de longitud n. El índice de los arrays en Java siempre empiezan en 0, por tanto la última posición será n-1. El índice nos permite acceder a un elemento determinado del array.

En los arrays multidimensionales tendremos tantos índices como dimensiones.


Declaración de un array

Un array se declara especificando el tipo del array a la variable:

char[] arrayCaracteres;
char arrayVocales [];        //posición de los corchetes legal pero menos legible.
String[] arrayCadenas;
int[] cuponOnce;
int[][] matriz;

La declaración del array crea una referencia que apuntará al array.
La declaración nunca debe indicar el tamaño del array.


Creación de un array

arrayCaracteres = new char[20];
arrayVocales = new char[5];
arrayCadenas = new String[3];

Después de su creación los arrays se inicializan con el valor predeterminado de su tipo.

Aunque hemos separado la declaración de la construcción del array, lo más usual es que la declaración y la construcción se hagan en una misma línea:

int[] notasTrimestres = new int[4];

Java también permite utilizar una forma abreviada para crear arrays con valores iniciales dando los valores entre llaves:

char[] letras = {‘a’, ‘b’, ‘c’, ‘d’};
String[] nombres = {“María”, “Jose”, “Alberto”}


Arrays multidimensionales

Dado que es posible declarar un array de cualquier tipo, los arrays multidimensionales en Java se crean mediante arrays de arrays.

Un array bidimensional:
//Crea un array de tres elementos en los que cada uno de ellos es un array.  
int [][] bidimensional = new int [3][];

Ahora podemos dar a cada uno de estos tres arrays dimensiones diferentes si queremos:
bidimensional[0] = new int[2];
bidimensional[1] = new int[3];
bidimensional[2] = new int[2];

Si todos nuestros arrays de arrays van a tener la misma dimensión podemos ahorrarnos esfuerzo y  se permite la siguiente declaración y construcción:

int [][] rectangular = new int[3][2]



Límites

En Java todos los arrays comienzan en 0. El número de elementos de un array se guarda en el
atributo del array length. Es recomendable utilizar este atributo cuando iteremos los elementos de un array para evitarnos acceder fuera de los límites permitidos.

Si intentamos acceder a una posición incorrecta del array se generará la excepción ArrayIndexOutOfBoundsException.



Dando Valores a un Array

Podemos rellenar los arrays dando valor a cada uno de sus elementos:

 public class Persona {
     private String nombre;
     private int edad;
     //... // Constructores, getters, setters

    public static void main (String[] args){
        Persona[] familia = new Persona[3];
        familia[0] = new Persona("Maria", 35);
        familia[1] = new Persona("Jose", 30);
        familia[2] = new Persona("Ana", 3);
    }
 }
 

O bien utilizando un bucle:

public class Persona{
    private String nombre;
    private int edad;
    //...// Constructores, getters, setters

    public static void main (String[] args){
        String[] nombres = {"Maria", "Jose", "Ana"};
        int[] edades = {35, 30, 3};
        Persona[] familia = new Persona[3];

        for (int i = 0; i< familia.length; i++){
           familia[i] = new Persona(nombres[i], edades[i]);
        }
     }
 }
 



Asignaciones Legales en Arrays

De tipos primitivos:  
Se puede asignar a una posición del array cualquier variable que pueda ser promovidos o convertidos al tipo del array.

Por ejemplo, en un array de enteros podemos incluir shorts, bytes, chars …

public class asignaArray{
  public static void main(String[] args){
      byte a = 3;
      short b = 30000;
      int c = 450;
      long d = 300000L;
      float e = 2500.203F;
      double f = 3234.25;
      char g = 'B';
      int [] enteros = new int[10];
      enteros[0] = a;
      enteros[1] = b;
      enteros[2] = c;
      enteros[3] = (int) d;
      enteros[4] = (int) e;v
      enteros[5] = (int) f;
      enteros[6] = g;
      enteros[7] = c/a;
      enteros[8] = (int) d/a;
      enteros[9] = (int) e/a;</p>
      for (int i = 0; i< enteros.length; i ++){
          System.out.println("enteros["+ i + "]: " + enteros[i]);
      }
    }
 }
 

De tipos de referencia: Se puede asignar cualquier subclase del tipo. Y si el tipo del array es una interfaz podemos asignar cualquier objeto que implemente dicha interfaz.


Por ejemplo, podríamos tener un array de Empleado con distintos tipos de empleado:

//...
 Empleado[] empleados = new Empleado[4];
 empleados[0]=new Tecnico();
 empleados[1]=new Secretario();
 empleados[2]=new Contable();
 empleados[3]=new Tecnico();

for (int i=0; i<empleados.length; i++){
    Empleado e = empleados[i];
    System.out.println(e.getNombre());
    System.out.println(e.getAntiguedad());
    System.out.println(e.getSueldo());
 }
 //...

Es incluso posible hacer una colección con objetos de cualquier clase, ya que en Java todos los
objetos heredan de Object:

Object [] objetos = new Object[5];
objetos[0] = new Empleado();
objetos[1] = new Batman();
objetos[2] = new Libro();
objetos[3] = new String("Maria");
objetos[4] = new Bicicleta();
Anuncios
 
4 comentarios

Publicado por en 8 octubre, 2011 en Estudio, Tema 3

 

Etiquetas: , , , , , , ,

4 Respuestas a “Asignaciones – Arrays

  1. Pablo Garrido

    12 septiembre, 2015 at 11:18 pm

    Si intentas asignar el valor de un elemento del array en un espacio que ya este ocupado(ej: si array[i]=2 y después yo asigno array[i]=5), el anterior valor se eliminaría o daría error?

     
  2. Nendrel

    4 septiembre, 2013 at 8:15 pm

    Añadir un par de cosas más respecto a los arrays que me parecen interesantes mencionar:

    Con notación extra para declarar, construir e inicializar un array en la misma línea
    int[] a = {1,2,3};
    en caso de que queramos hacer lo siguiente:
    int[] a;
    a = {1, 2, 3};
    esto nos va a dar error, ya que esa notación sólo sirve para cuando queremos hacer las tres cosas (declarar, construir e inicializar) en la misma línea.
    Para solucionar esto, existe otra notación llamada “creación anónima de arrays”. De esta forma sería así:
    int[] a;
    a = new int[] {1, 2, 3}; // Notar que no hay que especificar el tamaño entre los corchetes
    De esta manera crearemos un array que asignaremos a la variable de referencia a.
    Este tipo de creación de arrays va bien cuando por ejemplo queremos crear un array en un momento determinado para pasarlo como parámetro de un método.

    Otra cosa que quiero citar:
    – Un array de tipos primitivos no se puede meter en otro array de tipos primitivos si son de tipos diferentes aunque sean de mayor capacidad esos tipos primitivos. Es decir:
    byte[] bytes = new byte[4];
    int[] enteros = bytes; // MAL (diferente tipo aunque un byte quepa en un int)
    byte[] nuevoArray = bytes; // BIEN (arrays del mismo tipo)
    – Un array de referencias SÍ se puede meter en otro array de referencias si se cumple la regla IS-A. Es decir:
    Teniendo una clase Animal y una subclase Perro podríamos hacer:
    Perro[] perros = new Perros[3];
    Animal[] animales = perros; // BIEN porque Perro IS-A Animal.
    Sin embargo esto estaría mal:
    Animal[] animales = new Animal[3];
    Perro[] perros = animales; // MAL porque Animal no es un Perro.
    También funciona con clases que implementen interfaces, ya que se cumple la regla IS-A, porque una clase que implente una interface IS-A interface de ese tipo.

     
  3. David

    17 septiembre, 2012 at 6:11 pm

    public class Persona {
    02 private String nombre;
    03 private int edad;
    04 //… // Constructores, getters, setters
    05
    06 public static void main (String[] args){
    07 Persona[] familia = new Persona[3];
    08 Persona[0] = new Persona(“Maria”, 35);
    09 Persona[1] = new Persona(“Jose”, 30);
    10 Persona[2] = new Persona(“Ana”, 3);
    11 }
    12 }

    En este ejemplo, creo que hay un error, ya que ¿Persona[0] no debe ser familia[0]? y así con el resto de índices…

     
    • Virginia Lopez

      17 septiembre, 2012 at 8:32 pm

      Sí, efectivamente. El array se llama familia y es el que se indexa, Persona es solo el tipo.
      Sería familia[0] = new Persona(“Maria”,35); etc…

      Gracias, lo corrijo!

       

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s

 
A %d blogueros les gusta esto: