public class NodoLista4{
String nom;
int calif1;
int calif2;
int calif3;
}
import java.util.*;
public class ListaAlumnos{
static double prom;
public static void main( String args[] ){
Scanner leer = new Scanner(System.in);
NodoLista4 nodo = new NodoLista4();
int op;
ArrayList lista = new ArrayList();
do{
System.out.println( "Ingrese el nombre del alumno:" );
nodo.nom = leer.next();
System.out.println( "Ingrese la primera calificación:" );
nodo.calif1 = leer.nextInt();
System.out.println( "Ingrese la segunda calificación:" );
nodo.calif2 = leer.nextInt();
System.out.println( "Ingrese la tercera calificación:" );
nodo.calif3 = leer.nextInt();
lista.add("Nombre del alumno:\n"+nodo.nom);
lista.add("Calificación 1:\n"+nodo.calif1);
lista.add("Calificación 2:\n"+nodo.calif2);
lista.add("Calificación 3\n"+nodo.calif3);
promedio(nodo.calif1, nodo.calif2, nodo.calif3);
lista.add("Su promedio es:\n"+prom);
System.out.println( "¿Desea ingresar otro alumno?" );
System.out.println( "1.-Si\t 2.-No" );
op = leer.nextInt();
}
while(op != 2);
List lista2 = new ArrayList(lista);
Iterator it = lista2.iterator();
while (it.hasNext()){
System.out.println(it.next()+"");
}
}
private static double promedio(int calif1, int calif2, int calif3){
int suma = calif1 + calif2 + calif3;
prom = suma/3;
return prom;
}
}
1 oct 2010
21 sept 2010
practica
Listas en Java (ArrayList)
Realizar un programa que, pida el nombre de un alumno y de tres de sus calificaciones. Para Calcular su promedio.
Condición>>
ejemplo 5
Un mapa es una estructura de Java que nos permite almacenar pares clave/valor. De tal manera que para una clave solamente tenemos un valor.
Si añadimos un nuevo elemento clave/valor cuando la clave ya existe, se sobrescribe el valor almacenado anteriormente.
La estructura a listar que utilizamos como mapa es un HashMap. Lo primero que tenemos que hacer es crear el mapa y añadirle elementos:
Map<String,String> hm = new HashMap<String,String>();
hm.put("1","Luis");
hm.put("2","Amaya");
hm.put("3","Julio");
Si intentamos añadir otro elemento con una clave ya existente, sobreescribe el valor. Ya que no puede haber elementos duplicados.
Para recorrerlo nos apoyaremos sobre un Iterator que será el puntero encargado en recorrer los elementos del mapa. Obtendremos un iterador sobre la estructura invocando los métodos .entrySet() e .iterator(). Usar iteradores permite separar la lógica de la clase de la lógica de la iteración. Los iteradores tienen un comportamiento similar a los enumerados.
Para mover el iterador utilizaremos el método .next() y si queremos comprobar que el iterador ha llegado al final de la estructura tenemos el método .hasNext()
Iterator it = hm.entrySet().iterator();
while (it.hasNext()) {
Map.Entry e = (Map.Entry)it.next();
System.out.println(e.getKey() + " " + e.getValue());
}
codigo
import java.util.*;
public class ListarUnMapa {
public static void main(String[] args) {
Map<String,String> hm = new HashMap<String,String>();
hm.put("1","Luis");
hm.put("2","Amaya");
hm.put("3","Julio");
// Añadimos un elemento con clave existente. Se sobrescribe su valor
// ya que no puede haber valores duplicados
hm.put("1","Victor");
Iterator it = hm.entrySet().iterator();
while (it.hasNext()) {
Map.Entry e = (Map.Entry)it.next();
System.out.println(e.getKey() + " " + e.getValue());
}
}
}
ejemplo 4
En el siguiente ejemplo se muestra cómo volcar el contenido de un conjunto de datos (HashSet). Los conjuntos tienen la propiedad de que no pueden albergar nunca dos elementos con el mismo valor.
Lo primero que hacemos es cargar el conjunto...
Set hs = new HashSet();
hs.add("Victor");
hs.add("Amaya");
hs.add("Amaya"); // Los elementos solo pueden estar una vez
hs.add("Javier");
Notese que cargamos un elemento repetido (Amaya). Al volcar el contenido del conjunto veremos que dicho elemento solo aparece una vez.
Lo siguiente será conseguir un iterador sobre el conjunto...
Iterator iter = hs.iterator();
Solo nos quedará dicho iterador para volcar el contenido. Moveremos el iterador mediante el método .next().
while (iter.hasNext())
System.out.println(iter.next());
codigo
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class ListarConjunto {
public static void main(String[] args) {
Set<String> hs = new HashSet<String>();
hs.add("Victor");
hs.add("Amaya");
hs.add("Amaya"); // Los elementos solo pueden estar una vez
hs.add("Javier");
Iterator iter = hs.iterator();
while (iter.hasNext())
System.out.println(iter.next());
}
}
ejemplo 3
Lo más normal es que queramos recorrer una lista de inicio a fin. Pero, quien nos dice que no queramos hacer esto al revés. Es verdad que una opción sería dar la vuelta a la lista y recorrerla normalmente (como explica el artículo Invertir una lista).
Si para recorrer una lista, en Java, hacia delante nos basamos en el método .next() para recorrerla hacía atrás nos basaremos en el método .previous().
Pero antes de todo esto lo que tenemos que hacer es obtener un iterador sobre la lista. El iterador lo obtendremos del último elemento de la lista. El último elemento de la lista nos lo dará el método .size().
ListIterator iter = list.listIterator(list.size());
Controlaremos el inicio de la lista con el método .hasPrevious().
while (iter.hasPrevious())
System.out.println(iter.previous());
codigo
import java.util.*;
public class RecorrerListaHaciaAtras {
public static void main(String[] args) {
// Definimos una ArrayList
List<String> list = new ArrayList<String>();
// Añadimos elementos
list.add("Victor");
list.add("Amaya");
list.add("Julio");
// Obtenemos un Iterador y recorremos la lista.
ListIterator iter = list.listIterator(list.size());
while (iter.hasPrevious())
System.out.println(iter.previous());
}
}
ejemplo 2
Numero de elementos de una Lista en Java
Con este ejemplo vamos a ver como podemos saber el número de elementos que hay dentro de una lista en Java. Para ello nos vamos a apoyar en el interface List y en la clase ArrayList.
Lo primero que hacemos es dar de alta la lista e insertarle los elementos. Con esto pretendemos simular una situación en la cual tengamos una lista cargada con elementos, pero sin saber cuantos son.
Lo que hacemos es utilizar el interface List, el cual representa una colección de elementos ordenados. Lo que denominaríamos secuencia. Pero solo es un interface. Lo que necesitamos es utilizar una clase que implemente dicho interface. Es por ello que utilizamos la clase ArrayList.
Veamos como serian las líneas de código para cargar la lista:
// Definimos una ArrayList
List list = new ArrayList();
// Añadimos elementos
list.add("Andrea");
list.add("Amaya");
list.add("Julio");
Si lo que queremos saber es el número de elementos que hay en la lista deberemos de utilizar el método .size(). Es por ello que línea de código será la siguiente:
System.out.println("El numero de elementos de la lista es " + list.size());
codigo
import java.util.ArrayList;
import java.util.List;
public class NumeroElementosLista {
public static void main(String[] args) {
// TODO Auto-generated method stub
// Definimos una ArrayList
List<String> list = new ArrayList<String>();
// Añadimos elementos
list.add("Andrea");
list.add("Amaya");
list.add("Julio");
System.out.println("El numero de elementos de la lista es " + list.size());
}
}
ejemplo 1
Nuestro objetivo es el de recorrer los elementos de la lista en Java. El ejemplo constará de dos partes. En la primera definiremos la lista y la cargaremos con elementos. En la segunda parte utilizaremos un iterador para recorrer la lista.
Empecemos... Lo primero que deberemos de tener, obviamente, será una lista. Para ello utilizaremos una estructura del tipo ArrayList. Veamos como sería la línea de código:
// Definimos una ArrayList
List<String> list = new ArrayList<String>();
Antes las listas se podían crear como genéricas, ahora hay que indicarle el tipo de elemento que va a ser insertado. Podemos seguir creando listas genéricas, pero esto ya está obsoleto en el lenguaje Java.
Cargaremos dicha estructura con datos utilizando el método .add(elemento). En nuestro caso le cargamos con tres elementos:
// Añadimos elementos
list.add("Andrea");
list.add("Amaya");
list.add("Julio");
Una vez que tenemos nuestra lista nos bastará utilizar la clase Iterator para obtener un puntero que nos referencie a los elementos de la lista. En este punto tendremos que tener en cuenta que: el método hasNext() nos dice si hay más elementos y que el método .next() nos permite movernos al siguiente elemento.
// Obtenemos un Iterador y recorremos la lista.
Iterator iter = list.iterator();
while (iter.hasNext())
System.out.println(iter.next());
}
Suscribirse a:
Entradas (Atom)