Array

Array en Java es un tipo de variable el cual utilizamos para guardar datos. Array consiste en una colleccion o lista que contiene cero o mas tipos de datos, estos array utilizan un indice como punto de inicio cero 0 y el cual ese indice tambien se utilizando para acceder al valor dentro de elemento del array.

Los array son utiles para guardar multiples valores en una simple variable, el cual pueden ser organizado por medio de codigo para que pueda ser más legible y mantenible los datos dentro del array. Un array puede contener cualquier tipo de dato incluyendo numeros, cadena de caracteres y/o objetos.

Ejemplo de como es util el uso de array:

class Main {
  public static void main(String[] args) {
    String ocean1 = "Pacific";
    String ocean2 = "Atlantic";
    String ocean3 = "Indian";
    String ocean4 = "Arctic";
    String ocean5 = "Antarctic";

    String[] oceans = {
      "Pacific",
      "Atlantic",
      "Indian",
      "Arctic",
      "Antarctic"
    };

    for(int i = 0; i < 5; i++) {
      System.out.println(oceans[i]);
    }
  }
}

Como podemos ver en el ejemplo, en vez de crear cinco 5 variables separada, podemos usar una sola variable el cual contiene los cinco 5 element, utilizando corchete [...] simple que crea el array.

Creacion de array

• Al igual que la variable, se crean indicando el tipo de variable que se organiza el array y el nombre del array. Un par de corchetes [...] sigue el tipo para distinguir las array de variables.

class Main {
  public static void main(String[] args) {
    String[] oceans;
  }
}

• Array literal, utilizando llaves simple {...} , Creado utilizando como tamaño los elemento colocado dentro del contenido del array.

class Main {
  public static void main(String[] args) {      
    String[] oceans = {
      "Pacific",
      "Atlantic",
      "Indian",
      "Arctic",
      "Antarctic",
    };

    for(String ocean: oceans) {
      System.out.println(ocean);
    };
  }
}
//-> Pacific Atlantic Indian Arctic Antarctic

• Utilizando la palabra reservada o constructor new y inicializando el tamaño del array. En Java los array son objetos el cual pertenece a una clase dentro de Java. new <array-data-type>[<array-length>];

class Main {
  public static void main(String[] args) {
    String[] oceans = new String[10];
  }
}

Acceso a element de array

Para acceder a un elemento dentro del array, utilizamos la variable del array junto el indice del elemento en conchetes.

class Main {
  public static void main(String[] args) {
    String[] seaCreatures = {
      "octopus",
      "squid",
      "shark",
      "seahorse",
      "starfish"
    };
    System.out.println(seaCreatures[2]); //-> shark
  }
}

ArrayList

En Java los array regulares contienen un tamano fijo, los ArrayList nos permite crear un array el cual puede ser dinamico. En adicion estos contienen metodos el cual nos permite interactuar con los elemento del mismo array.

import java.util.List;
import java.util.ArrayList;
import java.util.Arrays;

class Main {
  public static void main(String[] args) {
    // Creating an ArrayList of String.
    List<String> seaCreature_01 = new ArrayList<>();

    // Creating an ArrayList with predefine values.
    List<String> seaCreatures_02 = new ArrayList<String>(
      Arrays.asList(
        "octopus",
        "squid",
        "shark",
        "seahorse",
        "starfish"
      )
    );

    for(String creature: seaCreatures_02) {
      System.out.println(creature);
      //-> octopus squid shark seahorse starfish
    };
  }
}

Añadir elemento a ArrayList

Si nuestra variable array contiene cinco 5 elementos, sus indices consiste de 0 a 4, si queremos añadir otro elemento podemos asignar el valor al proximo indice del array.

import java.util.ArrayList;
import java.util.List;
import java.util.Arrays;

class Main {
  public static void main(String[] args) {
    List<String> seaCreatures = new ArrayList<String>(
      Arrays.asList(
          "octopus",
          "squid",
          "shark",
          "seahorse",
          "starfish"
      )
    );

    seaCreatures.add("whale");

    for(String creature: seaCreatures) {
      System.out.println(creature);
      //-> octopus squid shark seahorse starfish whale
    };
  }
}

No es necesario asignar su valor indice, por defecto, el procesador de Java automaticamente añade el valor a su proximo espacio indice disponible. Tambien podemos anadir elemento basado a indice en dentro del array.

import java.util.ArrayList;
import java.util.List;
import java.util.Arrays;

class Main {
  public static void main(String[] args) {
    List<String> seaCreatures = new ArrayList<String>(
      Arrays.asList(
        "octopus",
        "squid",
        "shark",
        "seahorse",
        "starfish"
      )
    );

    seaCreatures.add(2, "whale");

    for(String creature: seaCreatures) {
      System.out.println(creature);
      //-> octopus squid whale shark seahorse starfish 
    };
  }
}

Podemos tambien unir dos array dentro de un solo array.

import java.util.ArrayList;
import java.util.List;
import java.util.Arrays;

class Main {
  public static void main(String[] args) {
    List<String> seaCreatures = new ArrayList<String>(
      Arrays.asList(
        "octopus",
        "squid",
        "shark"
      )
    );

    List<String> moreCreatures = new ArrayList<String>(
      Arrays.asList(
        "seahorse",
        "starfish",
        "whale"
      )
    );

    seaCreatures.addAll(moreCreatures);

    for(String creature: seaCreatures) {
      System.out.println(creature);
      //-> octopus squid shark seahorse starfish whale
    };
  }
}

Acceso y modificar a elementos de ArrayList

Tenemos varios metodos para tener acceso a ArrayList, como tambien verificar si ArrayList esta vacio o tienen elementos.

import java.util.ArrayList;
import java.util.List;
import java.util.Arrays;

class Main {
  public static void main(String[] args) {
    List<String> seaCreatures = new ArrayList<String>(
      Arrays.asList(
        "octopus",
        "squid",
        "shark",
        "seahorse",
        "starfish",
        "whale"
      )
    );

    // .isEmpty nos devuelve un valor booleano.
    System.out.println("Is the seaCreature list empty? : " + seaCreatures.isEmpty());
    //-> false

    // .size nos devuelve un valor int.
    System.out.println("seaCreature size is : " + seaCreatures.size());
    //-> 6

    // .get nos devuelve el valor basado en el indice del array.
    System.out.println(seaCreatures.get(2));
    //-> shark

    // .set remplaza valor basado en indice del array.
    System.out.println(seaCreatures.set(1, "shark"));

    for(String creature: seaCreatures) {
      System.out.println(creature);
      //-> octopus shark shark seahorse starfish whale
    };
  }
}

Remover elemento de ArrayList

Podemos utilizar el metodo remove para eleminar elementos de array usando el indice del array.

import java.util.ArrayList;
import java.util.List;
import java.util.Arrays;

class Main {
  public static void main(String[] args) {
    List<String> seaCreatures = new ArrayList<String>(
      Arrays.asList(
        "octopus",
        "squid",
        "shark",
        "seahorse",
        "starfish",
        "whale"
      )
    );

    seaCreatures.remove(2);

    for(String creature: seaCreatures) {
      System.out.println(creature);
      //-> octopus squid seahorse starfish whale
    };
  }
}