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());
}
realizacion
Las listas (List) aparecen en los interfaces de usuario para facilitar a los operadores la manipulación de muchos elementos. Se crean utilizando métodos similares a los de los botones Choice. La lista es visible todo el tiempo, utilizándose una barra de desplazamiento para visualizar los elementos que no caben en el área que aparece en la pantalla.
El ejemplo siguiente, Lista.java, crea una lista que muestra cuatro líneas a la vez y no permite selección múltiple.
import java.awt.*; import java.applet.Applet;public class Lista extends Applet {
public void init() {
List l = new List( 4,false );
l.addItem( "Mercurio" );
l.addItem( "Venus" );
l.addItem( "Tierra" );
l.addItem( "Marte" );
l.addItem( "Jupiter" );
l.addItem( "Saturno" );
l.addItem( "Neptuno" );
l.addItem( "Urano" );
l.addItem( "Pluton" );
add( l );
}
public boolean action( Event evt,Object obj ) {
if( evt.target instanceof List )
System.out.println( "Entrada de la Lista: " + obj );
return true;
}
}
Para acceder a los elementos seleccionados se utilizan los métodos getSelectedItem() o getSelectedItems(). Para listas de selección simple, cualquier selección con doble-click en la lista disparará el método action() de la misma forma que con los eventos de selección en menús.
En el applet siguiente, ListaMult.java, se permite al usuario seleccionar varios elementos de los que constituyen la lista. En la figura se muestra la apariencia de una selección múltiple en este applet.
mport java.awt.*;
import java.applet.Applet;
public class ListaMult extends Applet {
List lm = new List( 6,true );
public void init() {
Button boton = new Button( "Aceptar" );
lm.addItem( "Mercurio" );
lm.addItem( "Venus" );
lm.addItem( "Tierra" );
lm.addItem( "Marte" );
lm.addItem( "Jupiter" );
lm.addItem( "Saturno" );
lm.addItem( "Neptuno" );
lm.addItem( "Urano" );
lm.addItem( "Pluton" );
add( lm );
add( boton );
}
public boolean action( Event evt,Object obj ) {
if( evt.target instanceof Button )
{
if( "Aceptar".equals( obj ) )
{
String seleccion[];
seleccion = lm.getSelectedItems();
for( int i=0; i < seleccion.length; i++ )
System.out.println( seleccion[i] );
}
}
return true;
}
}
En este caso de la selección múltiple en una lista, utilizamos un evento externo para disparar las acciones asociadas a la lista. En el ejemplo, hemos incluido un botón para generar el evento que hace que el applet recoja los elementos que hay seleccionados en la lista.
Los botones de selección en una lista (Choice) permiten el rápido acceso a una lista de elementos. Por ejemplo, podríamos implementar una selección de colores y mantenerla en un botón Choice:
import java.awt.*;
import java.applet.Applet;
public class BotonSeleccion extends Applet {
Choice Selector;
public void init() {
Selector = new Choice();
Selector.addItem( "Rojo" );
Selector.addItem( "Verde" );
Selector.addItem( "Azul" );
add( Selector );
}
public boolean action( Event evt,Object obj ) {
if( evt.target instanceof Choice )
{
String color = (String)obj;
System.out.println( "El color elegido es el " + color );
}
return true;
}
}
casos de uso
A menudo en las interfaces de nuestros Apliques nos sucede que el usuario tiene que hacer una o más selecciones entre varias posibilidades. Para hacerlo podemos utilizar las listas, que representan una serie de objetos y dan la posibilidad de elegir. Pensemos, por ejemplo, en un aplique que gestiona las reservas de visitas guiadas de algunas localidades y que nos obligue a elegir una.
Además de las formas conocidas para el Nombre, Apellidos, etc.. tendremos la lista de las localidades
constructores:
List() , crear una nueva lista
List(int rows), crea una nueva lista con rows líneas
List(int rows, boolean multipleMode), crea una nueva lista con rows líneas, y se le dice que, según el valor booleano multipleMode, se podrán elegir uno o más elementos de la lista.
>void removeAll(), elimina todos los elementos de la lista.
>void removeActionListener(ActionListener l) e void removeItemListener(ItemListener l), eliminan los oyentes de sucesos definidos para la lista.
>void select(int index), selecciona el elemento indicado en la lista.
>void setMultipleMode(boolean b), dice a la lista si es posible seleccionar sólo un elemento o más de uno.
>void replaceItem(String newValue, int index), modifica el elemento especificado.
Las listas son unos buenos GUI para que el usuario ponga en marcha una opción entre las muchas posibilidades.
Hay otro GUI que sirve para esto, que prácticamente es una lista que aparece y desaparece, en el sentido de que se puede ver sólo el objeto seleccionado y que los demás se ven sólo cuando hay que hacer la selección, tipo menú, mientras en las listas se pueden ver siempre.
El GUI del que estoy hablando es el Choice (selección), cuyo funcionamiento es parecido al de las listas.
El constructor es uno sin parámetros, mientras los métodos son:
>void add(String item), añade una posibilidad al final de las selecciones posibles.
>void addItem(String item), como la add
>void addItemListener(ItemListener l), asocia un oyente de sucesos para la Choice.
>String getItem(int index), devuelve la elección posible que se encuentra en el índice .
>int getItemCount(), da el número de posibilidades para la Choice.
>EventListener[] getListeners(Class listenerType), da todos los oyentes asociados a la Choice.
>int getSelectedIndex(), devuelve el índice de la lista seleccionada en la Choice.
>String getSelectedItem(), devuelve la opción seleccionada en la Choice.
>Object[] getSelectedObjects(), da todos los item seleccionados.
>void insert(String item, int index), introduce una seleccióm en la posición indicada de la Choice.
>void remove(int position), void remove(String item), void removeAll() , para eliminar las selecciones posibles de la lista.
>void removeItemListener(ItemListener l), elimina el oyente de sucesos de tipo ItemListener asociado a la Choice.
>void select(int pos), void select(String str), para seleccionar una opción.
Además de las formas conocidas para el Nombre, Apellidos, etc.. tendremos la lista de las localidades
constructores:
List() , crear una nueva lista
List(int rows), crea una nueva lista con rows líneas
List(int rows, boolean multipleMode), crea una nueva lista con rows líneas, y se le dice que, según el valor booleano multipleMode, se podrán elegir uno o más elementos de la lista.
Algunos métodos que podemos utilizar en las listas son:
>void add(String item) e void add(String item, int index), para colgar, al final de la lista o en cierta posición, un nuevo componente.
>void addActionListener(ActionListener l), para asociar un ActionListener a la lista.
>void addItemListener(ItemListener l), para asociar un ItemListener a la lista.
>String getItem(int index), para tener el elemento en posición indicada.
>int getItemCount() , para obtener el número de los elementos.
>String[] getItems(), para obtener todos los elementos.
>EventListener[] getListeners(Class listenerType) , para obtener los oyentes asociados a la lista del tipo que queremos.
>Dimension getMinimumSize(), da el tamaño mínimo de la lista.
>Dimension getPreferredSize(), da el tamaño preferido para la lista.
>int getRows() , dice el número de líneas al momento visibles en la lista.
>Int getSelectedIndex(), da el índice del elemento seleccionado.
>int[] getSelectedIndexes(), da los índices de los elementos seleccionados.
>String getSelectedItem(), da el objeto seleccionado.
>String[]getSelectedItems(), da los objetos seleccionados.
>Object[] getSelectedObjects(), da la lista de los elementos seleccionados en un vector de objetos.
>boolean isIndexSelected(int index), dice si el índice está seleccionado.
>boolean isMultipleMode(), dice si, en la lista, se pueden seleccionar más elementos.
>void makeVisible(int index), visualiza el item en la posición indicada.
>void remove(int position), void remove(String item), elimina los elementos indicados por el
>void addActionListener(ActionListener l), para asociar un ActionListener a la lista.
>void addItemListener(ItemListener l), para asociar un ItemListener a la lista.
>String getItem(int index), para tener el elemento en posición indicada.
>int getItemCount() , para obtener el número de los elementos.
>String[] getItems(), para obtener todos los elementos.
>EventListener[] getListeners(Class listenerType) , para obtener los oyentes asociados a la lista del tipo que queremos.
>Dimension getMinimumSize(), da el tamaño mínimo de la lista.
>Dimension getPreferredSize(), da el tamaño preferido para la lista.
>int getRows() , dice el número de líneas al momento visibles en la lista.
>Int getSelectedIndex(), da el índice del elemento seleccionado.
>int[] getSelectedIndexes(), da los índices de los elementos seleccionados.
>String getSelectedItem(), da el objeto seleccionado.
>String[]getSelectedItems(), da los objetos seleccionados.
>Object[] getSelectedObjects(), da la lista de los elementos seleccionados en un vector de objetos.
>boolean isIndexSelected(int index), dice si el índice está seleccionado.
>boolean isMultipleMode(), dice si, en la lista, se pueden seleccionar más elementos.
>void makeVisible(int index), visualiza el item en la posición indicada.
>void remove(int position), void remove(String item), elimina los elementos indicados por el
índice o la etiqueta.
>void removeAll(), elimina todos los elementos de la lista.
>void removeActionListener(ActionListener l) e void removeItemListener(ItemListener l), eliminan los oyentes de sucesos definidos para la lista.
>void select(int index), selecciona el elemento indicado en la lista.
>void setMultipleMode(boolean b), dice a la lista si es posible seleccionar sólo un elemento o más de uno.
>void replaceItem(String newValue, int index), modifica el elemento especificado.
Las listas son unos buenos GUI para que el usuario ponga en marcha una opción entre las muchas posibilidades.
Hay otro GUI que sirve para esto, que prácticamente es una lista que aparece y desaparece, en el sentido de que se puede ver sólo el objeto seleccionado y que los demás se ven sólo cuando hay que hacer la selección, tipo menú, mientras en las listas se pueden ver siempre.
El GUI del que estoy hablando es el Choice (selección), cuyo funcionamiento es parecido al de las listas.
El constructor es uno sin parámetros, mientras los métodos son:
>void add(String item), añade una posibilidad al final de las selecciones posibles.
>void addItem(String item), como la add
>void addItemListener(ItemListener l), asocia un oyente de sucesos para la Choice.
>String getItem(int index), devuelve la elección posible que se encuentra en el índice .
>int getItemCount(), da el número de posibilidades para la Choice.
>EventListener[] getListeners(Class listenerType), da todos los oyentes asociados a la Choice.
>int getSelectedIndex(), devuelve el índice de la lista seleccionada en la Choice.
>String getSelectedItem(), devuelve la opción seleccionada en la Choice.
>Object[] getSelectedObjects(), da todos los item seleccionados.
>void insert(String item, int index), introduce una seleccióm en la posición indicada de la Choice.
>void remove(int position), void remove(String item), void removeAll() , para eliminar las selecciones posibles de la lista.
>void removeItemListener(ItemListener l), elimina el oyente de sucesos de tipo ItemListener asociado a la Choice.
>void select(int pos), void select(String str), para seleccionar una opción.
El último componente GUI que veremos en esta lección es el ScrollPane, es decir, un panel en el que es posible introducir un componente tan grande como queramos, y que tiene que ser visualizado a trozos.
El ScrollPane usa dos Scrollbar, una horizontal y otra vertical, para seleccionar la parte del GUI que queremos ver. La Scrollbar es un objeto también, por lo tanto, se puede introducir y gestionar en las proprias aplicaciones. En el ScrollPane se puede elegir si visualizar las Scrollbar siempre, nunca o sólo cuando sea necesario.
Un ScrollPane típico es el que utilizamos para visualizar un archivo de texto.
Hay dos tipos de constructores para el objeto:
ScrollPane(int sbp), crea un ScrollPane que pueda visualizar las Scrollbar definidas por spb.
Los valores posibles son :
ScrollPane.SCROLLBARS_ALWAYS siempre a la vista
ScrollPane.SCROLLBARS_AS_NEEDED a la vista sólo si lo necesitamos
ScrollPane.SCROLLBARS_NEVER nunca a la vista
ScrollPane(), crea un ScrollPane que pueda visualizar ScrollPane.SCROLLBARS_AS_NEEDED.
Entre los métodos, además de los que sirven para gestionar el ScrollPane, encontramos los de Container y de Component. En efecto, ScrollPane es una extensión de Container, por lo tanto, si lo vemos como un contenedor, se puede ver como un componente.
Un ScrollPane típico es el que utilizamos para visualizar un archivo de texto.
Hay dos tipos de constructores para el objeto:
ScrollPane(int sbp), crea un ScrollPane que pueda visualizar las Scrollbar definidas por spb.
Los valores posibles son :
ScrollPane.SCROLLBARS_ALWAYS siempre a la vista
ScrollPane.SCROLLBARS_AS_NEEDED a la vista sólo si lo necesitamos
ScrollPane.SCROLLBARS_NEVER nunca a la vista
ScrollPane(), crea un ScrollPane que pueda visualizar ScrollPane.SCROLLBARS_AS_NEEDED.
Entre los métodos, además de los que sirven para gestionar el ScrollPane, encontramos los de Container y de Component. En efecto, ScrollPane es una extensión de Container, por lo tanto, si lo vemos como un contenedor, se puede ver como un componente.
Suscribirse a:
Entradas (Atom)