ArrayList en Java, con ejemplos

// Declaracin de un ArrayList de "String". Puede ser de cualquier otro Elemento u

Objeto (float, Boolean, Object, ...)
ArrayList<String> nombreArrayList = new ArrayList<String>();
// Aade el elemento al ArrayList
nombreArrayList.add("Elemento");
// Aade el elemento al ArrayList en la posicin 'n'
nombreArrayList.add(n, "Elemento 2");
// Devuelve el numero de elementos del ArrayList
nombreArrayList.size();
// Devuelve el elemento que esta en la posicin '2' del ArrayList
nombreArrayList.get(2);
// Comprueba se existe del elemento ('Elemento') que se le pasa como parametro
nombreArrayList.contains("Elemento");
// Devuelve la posicin de la primera ocurrencia ('Elemento') en el ArrayList
nombreArrayList.indexOf("Elemento");
// Devuelve la posicin de la ltima ocurrencia ('Elemento') en el ArrayList
nombreArrayList.lastIndexOf("Elemento");
// Borra el elemento de la posicin '5' del ArrayList
nombreArrayList.remove(5);
// Borra la primera ocurrencia del 'Elemento' que se le pasa como parametro.
nombreArrayList.remove("Elemento");
//Borra todos los elementos de ArrayList
nombreArrayList.clear();

// Devuelve True si el ArrayList esta vacio. Sino Devuelve False

nombreArrayList.isEmpty();
// Copiar un ArrayList
ArrayList arrayListCopia = (ArrayList) nombreArrayList.clone();
// Pasa el ArrayList a un Array
Object[] array = nombreArrayList.toArray();

iterad

// Declaracin el ArrayList
ArrayList<String> nombreArrayList = new ArrayList<String>();

// Aadimos 10 Elementos en el ArrayList

for (int i=1; i<=10; i++){
nombreArrayList.add("Elemento "+i);
}

// Aadimos un nuevo elemento al ArrayList en la posicin 2

nombreArrayList.add(2, "Elemento 3");

// Declaramos el Iterador e imprimimos los Elementos del ArrayList

Iterator<String> nombreIterator = nombreArrayList.iterator();
while(nombreIterator.hasNext()){
String elemento = nombreIterator.next();
System.out.print(elemento+" / ");
}

Ejecutando esta cdigo obtenemos por pantalla lo siguiente:

Elemento 1 / Elemento 2 / Elemento 3 / Elemento 3 / Elemento 4 / Elemento 5 /

Elemento 6 / Elemento 7 / Elemento 8 / Elemento 9 / Elemento 10 /

// Recordar que previamente ya hemos declarado el ArrayList y el Iterator de la

siguiente forma:
// ArrayList<String> nombreArrayList = new ArrayList<String>();
// Iterator<String> nombreIterator = nombreArrayList.iterator();

// Obtenemos el numero de elementos del ArrayList

int numElementos = nombreArrayList.size();
System.out.println("nnEl ArrayList tiene "+numElementos+" elementos");

// Eliminamos el primer elemento del ArrayList, es decir el que ocupa la posicin '0'
System.out.println("n... Eliminamos el primer elemento del ArrayList
("+nombreArrayList.get(0)+")...");
nombreArrayList.remove(0);

// Eliminamos los elementos de ArrayList que sean iguales a "Elemento 3"

System.out.println("n... Eliminamos los elementos de ArrayList que sean iguales a
"Elemento 3" ...");
nombreIterator = nombreArrayList.iterator();
while(nombreIterator.hasNext()){
String elemento = nombreIterator.next();
if(elemento.equals("Elemento 3"))
nombreIterator.remove();
obtenido del Iterator

// Eliminamos el Elemento que hemos

// Imprimimos el ArrayList despues de eliminar los elementos iguales a "Elemento 3"

System.out.println("nImprimimos los elementos del ArrayList tras realizar las
eliminaciones: ");
nombreIterator = nombreArrayList.iterator();
while(nombreIterator.hasNext()){
String elemento = nombreIterator.next();
System.out.print(elemento+" / ");
}

// Mostramos el numero de elementos que tiene el ArrayList tras las eliminaciones:

numElementos = nombreArrayList.size();
System.out.println("nNumero de elementos del ArrayList tras las eliminaciones =
"+numElementos);

package ArrayList_Objetos;

public class PartidoFutbol {

private String equipoLocal;

private String equipoVisitante;

private int golesLocal;
private int golesVisitante;

public String getEquipoLocal() {

return equipoLocal;
}

public void setEquipoLocal(String equipoLocal) {

this.equipoLocal = equipoLocal;
}

public String getEquipoVisitante() {

return equipoVisitante;
}

public void setEquipoVisitante(String equipoVisitante) {

this.equipoVisitante = equipoVisitante;
}

public int getGolesLocal() {

return golesLocal;
}

public void setGolesLocal(int golesLocal) {

this.golesLocal = golesLocal;

public int getGolesVisitante() {

return golesVisitante;
}

public void setGolesVisitante(int golesVisitante) {

this.golesVisitante = golesVisitante;
}
}

LECTURA PARTIDOS DESDE TXT

// Nos creamos un ArrayList de objetos de la Clase "PartidoFutbol"

System.out.println("... Nos creamos un ArrayList de objetos de la Clase
"PartidoFutbol" ...");
ArrayList<PartidoFutbol> partidos = new ArrayList<PartidoFutbol>();

// Instanciamos el fichero donde estan los datos

File fichero = new File(nombreFichero);
Scanner s = null;

try {
// Leemos el contenido del fichero
System.out.println("... Leemos el contenido del fichero ...");

s = new Scanner(fichero);
// Obtengo los datos de los partidos de ftbol del fichero
while (s.hasNextLine()){
partido de ftbol)

String linea = s.nextLine(); // Obtengo una linea del fichero (un

String [] cortarString = linea.split("::");

datos del partido de futbol

// Obtengo los

PartidoFutbol partido = new PartidoFutbol(); // Creo un objeto de la

clase "PartidoFutbol"

// Pongo los atributos al objeto "partido"

partido.setEquipoLocal(cortarString[0]);
partido.setEquipoVisitante(cortarString[1]);
partido.setGolesLocal(Integer.parseInt(cortarString[2]));
partido.setGolesVisitante(Integer.parseInt(cortarString[3]));

// Aadimos el objeto "partido" al ArrayList

partidos.add(partido);
}

} catch (Exception e) {
e.printStackTrace();
} finally{
try {
if (s != null)
s.close();
} catch (Exception e2) {
e2.printStackTrace();

}
}

System.out.println("... Guardados "+partidos.size()+" partidos de ftbol ...");

MOSTRAR PARTIDOS:

System.out.println("n... Resultados de los partidos de Futbol ...");

Iterator<PartidoFutbol> itrPartidos = partidos.iterator();
while(itrPartidos.hasNext()){
PartidoFutbol partido = itrPartidos.next();
System.out.println(partido.getEquipoLocal() + " "
+ partido.getGolesLocal() + "-"
+ partido.getGolesVisitante() + " "
+ partido.getEquipoVisitante());
}

ELIMINAR PARTIDOS NO EMPATES

// Eliminamos los partidos de futbol del ArrayList, cuyo resultado

// no sea un empate
System.out.println("n... Tamao del ArrayList antes de eliminar partidos de futbol =
"+partidos.size()+" ...");
System.out.println("n... Eliminamos los partidos de futbol cuyo resultado no sea un
empate ...");
itrPartidos = partidos.iterator();
while(itrPartidos.hasNext()){
PartidoFutbol partido = itrPartidos.next();

// Si los goles no son iguale, eliminamos el partido

if(partido.getGolesLocal() != partido.getGolesVisitante())
itrPartidos.remove();
}

// Imprimimos los elementos del ArrayList

System.out.println("n... Tamao del ArrayList despues de eliminar partidos de futbol =
"+partidos.size()+" ...");
System.out.println("n... Resultados de los partidos de Futbol con empate ...");
itrPartidos = partidos.iterator();
while(itrPartidos.hasNext()){
PartidoFutbol partido = itrPartidos.next();
System.out.println(partido.getEquipoLocal() + " "
+ partido.getGolesLocal() + "-"
+ partido.getGolesVisitante() + " "
+ partido.getEquipoVisitante());
}

LEER NUMEROS QUITAR CEROS

ArrayList<ArrayList<Integer>> arrayListNumeros = new

ArrayList<ArrayList<Integer>>();

de la siguiente forma:

// Instanciamos el fichero donde estan los datos

File fichero = new File(nombreFichero);
Scanner s = null;

try {
// Leemos el contenido del fichero
System.out.println("... Leemos el contenido del fichero ...");
s = new Scanner(fichero);
// Obtengo los datos de los partidos de ftbol del fichero
while (s.hasNextLine()){
String linea = s.nextLine(); // Obtengo una linea del fichero con los

numeros

String [] cortarString = linea.split(" ");

numeros de la linea en un array

// Obtengo los

ArrayList<Integer> numeros = new ArrayList<Integer>();

// Pongo los numeros de la fila en el ArrayList
for (int i=0; i<cortarString.length; i++){
numeros.add(Integer.parseInt(cortarString[i]));
}
// Aado el ArrayList de enteros al ArratList de ArrayList
arrayListNumeros.add(numeros);
}

} catch (Exception e) {
e.printStackTrace();
} finally{
try {
if (s != null)
s.close();
} catch (Exception e2) {

e2.printStackTrace();
}
}

Para comprobar que hemos copiado bien los datos y para recorrer el ArrayList
de ArrayList de Enteros, vamos a imprimir por pantalla el contenido del ArrayList y lo
hacemos de la siguiente forma:

// Para ver que hemos leido bien los numeros del fichero, recorremos el ArrayList de
// ArrayList y lo mostramos por pantalla.
System.out.println("n... Contenido de los ArrayList del ArrayList ...");
Iterator<ArrayList<Integer>> itrArrayListNumeros = arrayListNumeros.iterator();
while(itrArrayListNumeros.hasNext()){
ArrayList<Integer> numeros = itrArrayListNumeros.next();
Iterator<Integer> itrNumeros = numeros.iterator();
while(itrNumeros.hasNext()){
int numero = itrNumeros.next();
System.out.print(numero+" ");
}
System.out.println();
}

ELIMINDO CEROS

// Recorremos los ArrayList que hay en el ArrayList y eliminamos los numeros que son
cero
itrArrayListNumeros = arrayListNumeros.iterator();
while(itrArrayListNumeros.hasNext()){

ArrayList<Integer> numeros = itrArrayListNumeros.next();

Iterator<Integer> itrNumeros = numeros.iterator();
while(itrNumeros.hasNext()){
int numero = itrNumeros.next();
if (numero == 0)
itrNumeros.remove();
}
}

Ahora borramos del ArrayList, los ArrayLit que estn vacos, preguntando con
el mtodo isEmpty(). Esto lo hacemos de la siguiente forma:

// Recorremos el ArrayList de los ArrayList y eliminamos los ArrayList que no

// contengan elementos
itrArrayListNumeros = arrayListNumeros.iterator();
while(itrArrayListNumeros.hasNext()){
ArrayList<Integer> numeros = itrArrayListNumeros.next();
// Si el ArrayList esta vacio, lo eliminamos del ArrayList
if (numeros.isEmpty())
itrArrayListNumeros.remove();
}

Con todo esto ya hemos eliminado los ceros, y los ArrayList que estaban
vacos. Ahora solo queda recorrer de nuevo el ArrayList de ArrayList y mostrar el
contenido tras realizar las eliminaciones de ceros. Esto lo hacemos de la siguiente
manera:

// Mostramos el ArrayList tras eliminar todos los ceros

String salida = "";

System.out.println("n... Salida sin ceros ...");
itrArrayListNumeros = arrayListNumeros.iterator();
while(itrArrayListNumeros.hasNext()){
ArrayList<Integer> numeros = itrArrayListNumeros.next();
Iterator<Integer> itrNumeros = numeros.iterator();
while(itrNumeros.hasNext()){
int numero = itrNumeros.next();
salida += numero+" ";
}
salida += "n";
}

System.out.println(salida);

String aux, aux2,cambio="";

StringTokenizer tokens=new StringTokenizer(parrafo[j],"." );

while(tokens.hasMoreTokens()){
i++;
aux2=tokens.nextToken();
aux2=aux2.trim();
aux=aux2.charAt(0)+"";
aux=aux.toUpperCase();
aux2=aux2.replaceFirst(aux2.charAt(0)+"", aux);
cambio=cambio+aux2+".";

/*Creo un objeto File. Recibe como parmetro la ruta completa con el

*nombre del fichero Para los usuarios de Windows la ruta seria
*mas o menos as:"c:\\MiFichero.txt"*/
File Ffichero=new File("/home/luis/Documentos/MiFichero.txt");

La siguiente funcin crea un fichero si no existe y escribe en el una

cadena que recibe como parmetro.

public static void EcribirFichero(File Ffichero,String SCadena){

try {
//Si no Existe el fichero lo crea
if(!Ffichero.exists()){
Ffichero.createNewFile();
}
/*Abre un Flujo de escritura,sobre el fichero con codificacion
utf-8.
*Adems en el pedazo de sentencia
"FileOutputStream(Ffichero,true)",
*true es por si existe el fichero seguir aadiendo texto y no
borrar lo que tenia*/
BufferedWriter Fescribe=new BufferedWriter(new
OutputStreamWriter(new FileOutputStream(Ffichero,true), "utf-8"));
/*Escribe en el fichero la cadena que recibe la funcin.
*el string "\r\n" significa salto de linea*/
Fescribe.write(SCadena + "\r\n");
//Cierra el flujo de escritura
Fescribe.close();
} catch (Exception ex) {
//Captura un posible error le imprime en pantalla
System.out.println(ex.getMessage());
}
}

La siguiente funcin permite leer el contenido de un fichero de texto

linea a linea

/*Funcin que lee el contenido de un fichero de texto

*Parmetro:Ffichero. Objeto de la clase file donde se va a leer*/
public static void LeerFichero(File Ffichero){
try {
/*Si existe el fichero*/
if(Ffichero.exists()){
/*Abre un flujo de lectura a el fichero*/
BufferedReader Flee= new BufferedReader(new
FileReader(Ffichero));
String Slinea;
System.out.println("**********Leyendo Fichero***********");
/*Lee el fichero linea a linea hasta llegar a la ultima*/
while((Slinea=Flee.readLine())!=null) {

/*Imprime la linea leida*/

System.out.println(Slinea);
}
System.out.println("*********Fin Leer Fichero**********");
/*Cierra el flujo*/
Flee.close();
}else{
System.out.println("Fichero No Existe");
}
} catch (Exception ex) {
/*Captura un posible error y le imprime en pantalla*/
System.out.println(ex.getMessage());
}
}

Para borrar un archivo usamos este mtodo.

/* Mtodo que borra un fichero si existe
*Parmetro:Ffichero. Objeto de la clase file donde se va a borrar
*/
public static void BorrarFichero(File Ffichero){
try {
/*Si existe el fichero*/
if(Ffichero.exists()){
/*Borra el fichero*/
Ffichero.delete();
System.out.println("Fichero Borrado con Exito");
}
} catch (Exception ex) {
/*Captura un posible error y le imprime en pantalla*/
System.out.println(ex.getMessage());
}
}

Para modificar un registro dentro de un fichero.

/***********************************************************
* Modificar un fichero de texto, consiste en leer un archivo
*y escribir su con tenido en uno nuevo llamado X, excepto la
*linea a modificar que se remplaza con la linea nueva.Luego
*se borra el fichero inicial y se renombra el nuevo fichero
*con el nombre del archivo inicial
***********************************************************
*PARMETROS:
*FficheroAntiguo:Objeto File del fichero a modificar
*Satigualinea:Linea que se busca para modificar
*Snuevalinea:Linea con la que se va a remplazar la vieja
***********************************************************/
public static void ModificarFichero(File FficheroAntiguo,String
Satigualinea,String Snuevalinea){
/*Obtengo un numero aleatorio*/
Random numaleatorio= new Random(3816L);
/*Creo un nombre para el nuevo fichero apartir del
*numero aleatorio*/
String SnombFichNuev=FficheroAntiguo.getParent()
+"/auxiliar"+String.valueOf(Math.abs(numaleatorio.nextInt()))+".txt";
/*Crea un objeto File para el fichero nuevo*/
File FficheroNuevo=new File(SnombFichNuev);

try {
/*Si existe el fichero inical*/
if(FficheroAntiguo.exists()){
/*Abro un flujo de lectura*/
BufferedReader Flee= new BufferedReader(new
FileReader(FficheroAntiguo));
String Slinea;
/*Recorro el fichero de texto linea a linea*/
while((Slinea=Flee.readLine())!=null) {
/*Si la lia obtenida es igual al la bucada
*para modificar*/
if
(Slinea.toUpperCase().trim().equals(Satigualinea.toUpperCase().trim())) {
/*Escribo la nueva linea en vez de la que tenia*/
EcribirFichero(FficheroNuevo,Snuevalinea);
}else{
/*Escribo la linea antigua*/
EcribirFichero(FficheroNuevo,Slinea);
}
}
/*Obtengo el nombre del fichero inicial*/
String SnomAntiguo=FficheroAntiguo.getName();
/*Borro el fichero inicial*/
BorrarFichero(FficheroAntiguo);
/*renombro el nuevo fichero con el nombre del
*fichero inicial*/
FficheroNuevo.renameTo(FficheroAntiguo);
/*Cierro el flujo de lectura*/
Flee.close();
}else{
System.out.println("Fichero No Existe");
}
} catch (Exception ex) {
/*Captura un posible error y le imprime en pantalla*/
System.out.println(ex.getMessage());
}
}

private void jButton2ActionPerformed(java.awt.event.ActionEvent evt) {

String direccion=JOptionPane.showInputDialog("Ingrese la direccion de la
imagen del actor porfavor:\n Ej:(C:\\Users\\TOSHIBA\\Pictures\\fond\\103try.jpg)
");
if(direccion==null ){}
else{
if(direccion.equals("")){}
else{
String direcciofinal=direccion.replace("\\", "\\\\");
//C:\Users\TOSHIBA\Pictures\fond

try {
direccion=direcciofinal;
Runtime.getRuntime().exec("cmd /c
move \""+direccion+"\" \"c:\\BaseGraficadeDatos\\\" ");

} catch (IOException ex) {

Logger.getLogger(Aplicacion.class.getName()).log(Level.SEVERE, null,
ex);
}
this.nombrearchivo=direccion.substring(direccion.lastIndexOf("\\")+1);
}
}

String [] cortarString = linea.split("");

Random randd = new Random();
int aleatorio=0;
aleatorio=randd.nextInt(3);
Iterator iterador=this.personal.iterator();
String despliegue="";
while(iterador.hasNext()){
despliegue+=iterador.next()+"\n\n";
}
return despliegue;
public Object profesionalconmayorexp(){
Object objeto=Collections.min(this.personal, new
ComparadorFecha());

if (objeto instanceof Medico) {return (Medico)objeto;}

else{return(Auxiliar_Medico)objeto;}
}
private ArrayList<PalabraSignificado> palabras;

palabras=new ArrayList<PalabraSignificado>();
public PalabraSignificado buscar(String palabraabuscar){
for(PalabraSignificado palabraux:palabras){
if(palabraabuscar.compareToIgnoreCase(palabraux.getPalabra())==0){
return palabraux;}}
PalabraSignificado noencontrada=new PalabraSignificado("","");
return noencontrada;
}
___________________________________________________________________public void guardarenfichero(){
String texto="";
for(Bus aux:this.Lista){
texto+=aux;
}
try{
FileWriter fichero = new FileWriter("nombre.txt");
fichero.write(texto + "\r\n");
fichero.close();
}catch(Exception ex){
ex.printStackTrace();
}
}
______________________________________________________________________