PROGRAMACION COLECCIONES SHEILA NIETO UREÑA 1

PROGRAMACION
COLECCIONES
SHEILA NIETO UREÑA
LISTAS
 Crear y ver listas. Insertar elementos en cabecera, contar nodos, buscar el mayor elemento y buscar
un elemento dentro de una lista.
 Menú Listas.
 Suma, resta, intersección y unión de listas.
 Mismo ejercicio que el primero, pero utilizando interfaz.
 Lista de alumnos usando interfaz.
PILAS
 Interface. Insertar, extraer y mostrar pilas. Pila vacía.
ARRAYLIST
 Tablas dinámicas. Crear arraylist. Insertar elementos, tamaño, visualizar, añadir en una posición
específica, cambiar un elemento por otro, buscar elemento, eliminar elemento. Visualizar (varios
métodos).
 Ordenar un ArrayList de tipo entero.
 Ordenar un ArrayList de tipo String.
 Programa Java que pida por teclado las alturas de N alumnos de una clase y las guarde en un
ArrayList de tipo Double. A continuación, el programa calculará cuántos alumnos hay por encima de
la media y cuántos por debajo.
Para resolverlo vamos a utilizar 4 métodos además del método main:
 Método numeroAlumnos(): este método pide por teclado el número de alumnos de la clase y
devuelve dicho número al programa principal.
 Método leerAltura(): pide por teclado las alturas de los N alumnos y las almacena en el ArrayList.
Este método recibe como parámetros el ArrayList inicialmente vacío y el número de alumnos a
leer.
 Método calcularMedia(): calcula y devuelve la media de los alumnos de la clase. Este método
recibe como parámetro el ArrayList con las alturas de todos los alumnos.
 Método mostrarResultados(): muestra por pantalla todas las alturas y calcula y muestra el
número de alumnos con altura superior e inferior a la media. Recibe como parámetros el
ArrayList con las alturas de todos los alumnos y la media calculada anteriormente.
 Programa que lea una serie de valores numéricos enteros desde el teclado y los guarde en un
ArrayList de tipo Integer. La lectura de números termina cuando se introduzca el valor -99. Este valor
no se guarda en el ArrayList. A continuación el programa mostrará por pantalla el número de valores
que se han leído, su suma, su media. Por último se mostrarán todos los valores leídos, indicando
cuántos de ellos son mayores que la media.
Vamos a utilizar 3 métodos además del método main para resolverlo:
 Método leerValores(): pide por teclado los números y los almacena en el ArrayList. La lectura
acaba cuando se introduce el valor -99. El método devuelve mediante return el ArrayList con los
valores introducidos.
1
PROGRAMACION
COLECCIONES
SHEILA NIETO UREÑA
 Método calcularSuma(): Recibe como parámetro el ArrayList con los valores numéricos y calcula
y devuelve su suma. En este método se utiliza un Iterator para recorrer el ArrayList.
 Método mostrarResultados(): Recibe como parámetro el ArrayList, la suma y la media aritmética.
Muestra por pantalla todos los valores, su suma y su media y calcula y muestra cuantos números
son superiores a la media. En este método se utiliza un foreach para recorrer el ArrayList.
 Escribir un programa Java que cree un ArrayList de Objetos de tipo Coche. El programa pide por
teclado los datos de los coches y los guarda en el ArrayList. A continuación, utilizará el ArrayList para
mostrar por pantalla lo siguiente:
 Todos los coches introducidos.
 Todos los coches de una marca determinada.
 Todos los coches con menos de un número determinado de Kilómetros, que se pedirá por
teclado.
 El coche con mayor número de Kilómetros.
La clase coche tiene los atributos privados:




Matricula (String)
Marca (String)
Modelo (String)
Km (int)
 Clase Persona (nombre y edad).
INTERFAZ COMPARABLE
 Clase Artículo (nombre y valor).
 Hacer un programa que nos pida 3 calificaciones por alumno. Posteriormente, calcular la media por
alumno y la media del grupo. Visualizar la lista ordenada por nombre y luego por la primera
calificación. Hacer una búsqueda de un nombre dado por teclado indicando si está o no en la lista.
Buscar la mayor y menor nota media.
 List, ArrayList y LinkedList.
LIST, LINKEDLIST, SET
 Crear una colección ordenada de frutas y sin elementos repetidos.
2
PROGRAMACION
COLECCIONES
SHEILA NIETO UREÑA
INDICE
LISTAS ........................................................................................................................................................................... 5
listas .............................................................................................................................................................................. 5
Lista........................................................................................................................................................................... 5
MenuLista ................................................................................................................................................................. 8
SumarListas............................................................................................................................................................. 10
listaInterface ............................................................................................................................................................... 13
ListaInterface .......................................................................................................................................................... 13
Listas ....................................................................................................................................................................... 13
AppMain ................................................................................................................................................................. 15
alumInterface ............................................................................................................................................................. 16
ListaAlum ................................................................................................................................................................ 16
Alumno ................................................................................................................................................................... 16
ListadoAlum ............................................................................................................................................................ 16
AppMain ................................................................................................................................................................. 18
PILAS ........................................................................................................................................................................... 19
pilas............................................................................................................................................................................. 19
PilasInterface .......................................................................................................................................................... 19
Pilas......................................................................................................................................................................... 19
AppPila .................................................................................................................................................................... 20
ARRAYLIST ................................................................................................................................................................... 21
arraylist ....................................................................................................................................................................... 21
TablasDinamicas ..................................................................................................................................................... 21
OrdenarNum ........................................................................................................................................................... 22
OrdenarCad ............................................................................................................................................................ 22
Altura (useLocale - printf) ....................................................................................................................................... 23
SumaMedia ............................................................................................................................................................. 24
coches ......................................................................................................................................................................... 25
AppCoches .............................................................................................................................................................. 25
Coche ...................................................................................................................................................................... 25
Coches .................................................................................................................................................................... 26
INTERFAZ COMPARABLE............................................................................................................................................. 27
persona ....................................................................................................................................................................... 27
Persona ................................................................................................................................................................... 27
OrdenarPers............................................................................................................................................................ 28
3
PROGRAMACION
COLECCIONES
SHEILA NIETO UREÑA
articulo........................................................................................................................................................................ 28
Articulo ................................................................................................................................................................... 28
AppArticulo ............................................................................................................................................................. 29
calificaciones............................................................................................................................................................... 30
Alumno ................................................................................................................................................................... 30
OrdenarNota........................................................................................................................................................... 32
AppAlumno ............................................................................................................................................................. 32
LIST, LINKEDLIST, SET .................................................................................................................................................. 33
list ............................................................................................................................................................................... 33
ClaseList .................................................................................................................................................................. 33
set ............................................................................................................................................................................... 34
Frutas ...................................................................................................................................................................... 34
4
PROGRAMACION
LISTAS
COLECCIONES
SHEILA NIETO UREÑA
listas
Lista
package listas;
import java.util.Scanner;
public class Lista {
class Nodo{
int info;
Nodo sig;
}
private Nodo raiz;
public Lista(){
raiz=null;
}
public static void main(String[]args){
Scanner sc=new Scanner(System.in);
Lista l=new Lista();
Lista l2=new Lista();
int num=0;
//
System.out.print("Introduce numero: ");
//
num=sc.nextInt();
//
l.insertar(num);
for (int i=0;i<5;i++){
num=(int)(Math.random()*25);
l.insertar(num);
}
l.listar();
l.contarNodos();
System.out.println("\nLa lista tiene "+l.contadorNodos()+" nodos");
l.eleMayor();
System.out.print("\nIntroduce el numero a buscar: ");
int ele=sc.nextInt();
if(l.buscar(ele)) //o if(l.buscarSoco(ele))
System.out.println(ele+" esta en la lista");
else
System.out.println(ele+" no esta en la lista");
System.out.println("\nLISTA ORDENADA");
for (int i=0;i<5;i++){
num=(int)(Math.random()*25);
l2.insertarOrdenado(num);
}
l2.listar();
}
sc.close();
public void insertar(int ele){
Nodo nuevo=new Nodo();
nuevo.info=ele;
if(raiz==null){ //lista vacia
nuevo.sig=null;
raiz=nuevo;
}else{ //lista contiene informacion. Insertamos en la primera posicion
nuevo.sig=raiz;
raiz=nuevo;
}
5
PROGRAMACION
COLECCIONES
SHEILA NIETO UREÑA
}
public void listar(){
Nodo aux=raiz;
//instanciacion de la clase Nodo llamada aux igual a raiz y
no "new"
while (aux!=null) {
System.out.print(aux.info+"\t");
aux=aux.sig;
}
}
public void insertarOrdenado(int ele){
Nodo nuevo=new Nodo();
Nodo ant=raiz, act=raiz;
while((act!=null) && (act.info<ele)){
ant=act;
act=act.sig;
}
nuevo.info=ele;
//Insertar al principio
if(ant==act){
nuevo.sig=ant;
raiz=(nuevo);
}else{ //insertar en medio o al final
nuevo.sig=act;
ant.sig=nuevo;
}
}
public void borrar(int ele){
Nodo ant=raiz, act=raiz;
//buscar posicion del elemento a borrar
while((act!=null) && (act.info!=ele)){
ant=act;
act=act.sig;
}
//comprobar si esta el ele para poder borrarlo
if((ant!=null) && (act.info==ele))
//primer ele lista
if(ant==act)
raiz=act.sig;
else
//en medio al final
ant.sig=act.sig;
//Si no esta el elemento
else
System.out.println("El elemento NO se encuentra en la lista");
System.out.println("Lista despues de borrar el nº "+ele+": ");
listar();
}
public void borrarLista(){
Nodo act=raiz;
while(act!=null){
act=act.sig;
raiz=act;
}
}
public void contarNodos(){
Nodo aux=raiz;
int con=0;
while (aux!=null) {
con++;
aux=aux.sig;
}
System.out.println("\nLa lista tiene "+con+" nodos");
6
PROGRAMACION
COLECCIONES
SHEILA NIETO UREÑA
}
public int contadorNodos(){
Nodo aux=raiz;
int con=0;
while (aux!=null) {
con++;
aux=aux.sig;
}
return con;
}
public void eleMayor(){
Nodo aux=raiz;
int mayor=Integer.MIN_VALUE; //mayor=aux.info;
for(int i=0;i<contadorNodos();i++){
if(aux.info>mayor)
mayor=aux.info;
aux=aux.sig;
}
System.out.println("El elemento de la lista de mayor valor es: "+mayor);
}
public boolean buscar(int ele){
Nodo aux=raiz;
boolean esta=false;
while (aux.sig!=null) {
if(aux.info==ele){
esta=true;
break;
}
aux=aux.sig;
}
return esta;
}
//metodo mas eficiente que el metodo buscar
public boolean buscarSoco(int ele){
Nodo aux=raiz;
boolean esta=false;
while (aux.sig!=null && aux.info!=ele)
aux=aux.sig;
if(aux.info==ele)
esta=true;
return esta;
}
}
7
PROGRAMACION
COLECCIONES
MenuLista
package listas;
import java.util.Scanner;
public class MenuLista {
class Nodo{
int info;
Nodo sig;
}
private Nodo raiz;
public MenuLista(){
raiz=null;
}
static Scanner sc=new Scanner (System.in);
static int num, opc;
public static void main (String[]args){
MenuLista ml=new MenuLista();
ml.crearLista();
ml.listar();
ml.menu();
sc.close();
}
public void listadoMenu(){
System.out.println("\n\tMENU");
System.out.println("1. Insertar");
System.out.println("2. Insertar ordenado");
System.out.println("3. Visualizar");
System.out.println("4. Mayor");
System.out.println("0. Salir");
System.out.print("\tIntroduzca una opcion: ");
}
public void menu() {
do{
do{
listadoMenu();
opc=sc.nextInt();
}while (opc<0 || opc>4);
switch (opc){
case 1: insertar(leerNum());
break;
case 2: insertaOrdenado(leerNum());
break;
case 3: listar();
break;
case 4: contadorNodos();
eleMayor();
break;
case 0: System.out.println("\nHASTA PRONTO");
break;
}
}while (opc!=0);
}
public void crearLista() {
num=0;
for (int i=0;i<5;i++){
num=(int)(Math.random()*25);
insertar(num);
}
System.out.println();
}
8
SHEILA NIETO UREÑA
PROGRAMACION
COLECCIONES
SHEILA NIETO UREÑA
public int leerNum() {
System.out.print("\nIntroduce numero a insertar: ");
num=sc.nextInt();
return num;
}
public void insertar(int ele){
Nodo nuevo=new Nodo();
nuevo.info=ele;
if(raiz==null){
nuevo.sig=null;
raiz=nuevo;
}else{
nuevo.sig=raiz;
raiz=nuevo;
}
}
public void listar(){
Nodo aux=raiz;
System.out.print("LISTA: ");
while (aux!=null) {
System.out.print(aux.info+"\t");
aux=aux.sig;
}
System.out.println();
}
public void insertaOrdenado(int ele){
Nodo nuevo=new Nodo();
Nodo ant=raiz, act=raiz;
while((act!=null) && (act.info<ele)){
ant=act;
act=act.sig;
}
nuevo.info=ele;
if(ant==act){
//Insertar al principio
nuevo.sig=ant;
raiz=(nuevo);
}else{ //insertar en medio o al final
nuevo.sig=act;
ant.sig=nuevo;
}
}
public int contadorNodos(){
Nodo aux=raiz;
int con=0;
while (aux!=null) {
con++;
aux=aux.sig;
}
return con;
}
public void eleMayor(){
Nodo aux=raiz;
int mayor=Integer.MIN_VALUE;
for(int i=0;i<contadorNodos();i++){
if(aux.info>mayor)
mayor=aux.info;
aux=aux.sig;
}
System.out.println("\nEl elemento de la lista de mayor valor es: "+mayor);
}
}
9
PROGRAMACION
COLECCIONES
SumarListas
package listas;
public class SumarListas {
class Nodo{
int info;
Nodo sig;
}
private Nodo raiz;
public SumarListas(){
raiz=null;
}
static int num;
static SumarListas l1=new
static SumarListas l2=new
static SumarListas ls=new
static SumarListas lr=new
static SumarListas li=new
static SumarListas lu=new
SumarListas();
SumarListas();
SumarListas();
SumarListas();
SumarListas();
SumarListas();
public static void main(String[]args){
l1.crearLista();
l2.crearLista();
l2.insertarOrdenado(3);
System.out.print("LISTA 1:\t");
l1.listar();
System.out.print("LISTA 2:\t");
l2.listar();
ls.suma(l1, l2);
System.out.print("LISTA SUMA:\t");
ls.listar(); //el resultado aparecera de forma inversa
lr.resta(l1, l2);
System.out.print("LISTA RESTA:\t");
lr.listar(); //el resultado aparecera de forma inversa
li.interseccion(l1, l2, li);
System.out.print("LISTA INTERSECCION:\t");
li.listar();
lu.union(l1, l2, lu);
System.out.print("LISTA UNION:\t");
lu.listar();
}
public void crearLista() {
num=0;
for (int i=0;i<5;i++){
num=(int)(Math.random()*15);
insertarOrdenado(num);
}
System.out.println();
}
public void listar(){
Nodo aux=raiz;
while (aux!=null) {
System.out.print(aux.info+"\t");
aux=aux.sig;
}
System.out.println();
}
public void insertar(int ele){
Nodo nuevo=new Nodo();
nuevo.info=ele;
if(raiz==null){
nuevo.sig=null;
10
SHEILA NIETO UREÑA
PROGRAMACION
COLECCIONES
raiz=nuevo;
}else{
nuevo.sig=raiz;
raiz=nuevo;
}
}
public void insertarOrdenado(int num){
Nodo nuevo=new Nodo();
Nodo ant=raiz, act=raiz;
while((act!=null) && (act.info<num)){
ant=act;
act=act.sig;
}
nuevo.info=num;
if(ant==act){
nuevo.sig=ant;
raiz=(nuevo);
}else{
nuevo.sig=act;
ant.sig=nuevo;
}
}
public void suma(SumarListas l1,SumarListas l2){
Nodo aux=l1.raiz;
Nodo aux2=l2.raiz;
while (aux!=null && aux2!=null) {
num=aux.info+aux2.info;
insertar(num);
aux=aux.sig;
aux2=aux2.sig;
}
if(aux!=null){
while (aux!=null) {
insertar(aux.info);
aux=aux.sig;
}
}
if(aux2!=null){
while (aux2!=null) {
insertar(aux2.info);
aux2=aux2.sig;
}
}
System.out.println();
}
public void resta(SumarListas l1,SumarListas l2){
Nodo aux=l1.raiz;
Nodo aux2=l2.raiz;
while (aux!=null && aux2!=null) {
num=aux.info-aux2.info;
insertar(num);
aux=aux.sig;
aux2=aux2.sig;
}
if(aux!=null){
while (aux!=null) {
insertar(aux.info);
aux=aux.sig;
}
}
if(aux2!=null){
while (aux2!=null) {
insertar(aux2.info);
11
SHEILA NIETO UREÑA
PROGRAMACION
}
COLECCIONES
SHEILA NIETO UREÑA
aux2=aux2.sig;
}
System.out.println();
}
public void interseccion(SumarListas l1,SumarListas l2,SumarListas l3){
Nodo aux1=l1.raiz;
Nodo aux2=l2.raiz;
Nodo aux3=l2.raiz;
int auxTotal;
do{
do{
if(aux1.info==aux2.info){
auxTotal=aux1.info;
l3.insertar(auxTotal);
aux2=aux2.sig;
}else{
aux2=aux2.sig;
}
}while(aux2!=null);
aux2=aux3;
aux1=aux1.sig;
}while(aux1!=null);
}
public void union (SumarListas l1,SumarListas l2,SumarListas l3){
Nodo aux1=l1.raiz;
Nodo aux2=l2.raiz;
int auxTotal;
}
}
while(aux1!=null && aux2!=null){
auxTotal=aux1.info;
l3.insertar(auxTotal);
aux1=aux1.sig;
if (aux1==null || aux2==null){
auxTotal=aux2.info;
l3.insertar(auxTotal);
aux2=aux2.sig;
}
}
12
PROGRAMACION
listaInterface
COLECCIONES
SHEILA NIETO UREÑA
ListaInterface
package listaInteface;
public interface ListaInterface {
public abstract void insertar(int ele);
public void listar();
public void insertarOrdenado(int ele);
public void borrar(int ele);
public void contarNodos();
public int contadorNodos();
public void eleMayor();
public boolean buscar(int ele);
public boolean buscarSoco(int ele);
}
Listas
package listaInteface;
public class Listas implements ListaInterface{
public class Nodo{
int info;
Nodo sig;
}
private Nodo raiz;
public void Lista(){ //¿o public void Nodo?
raiz=null;
}
public void insertar(int ele){
Nodo nuevo=new Nodo();
nuevo.info=ele;
if(raiz==null){
//lista vacia
nuevo.sig=null;
raiz=nuevo;
}else{
//lista contiene informacion. Insertamos en la primera
posicion
nuevo.sig=raiz;
raiz=nuevo;
}
}
public void listar(){
Nodo aux=raiz;
//instanciacion de la clase Nodo llamada aux igual a
raiz y no "new"
while (aux!=null) {
System.out.print(aux.info+"\t");
aux=aux.sig;
}
}
public void insertarOrdenado(int ele){
Nodo nuevo=new Nodo();
Nodo ant=raiz, act=raiz;
while((act!=null) && (act.info<ele)){
ant=act;
act=act.sig;
}
nuevo.info=ele;
//Insertar al principio
if(ant==act){
nuevo.sig=ant;
13
PROGRAMACION
COLECCIONES
SHEILA NIETO UREÑA
raiz=(nuevo);
}else{ //insertar en medio o al final
nuevo.sig=act;
ant.sig=nuevo;
}
}
public void borrar(int ele){
}
public void contarNodos(){
Nodo aux=raiz;
int con=0;
while (aux!=null) {
con++;
aux=aux.sig;
}
System.out.println("\nLa lista tiene "+con+" nodos");
}
public int contadorNodos(){
Nodo aux=raiz;
int con=0;
while (aux!=null) {
con++;
aux=aux.sig;
}
return con;
}
public void eleMayor(){
Nodo aux=raiz;
int mayor=Integer.MIN_VALUE; //mayor=aux.info;
for(int i=0;i<contadorNodos();i++){
if(aux.info>mayor)
mayor=aux.info;
aux=aux.sig;
}
System.out.println("El elemento de la lista de mayor valor es: "+mayor);
}
public boolean buscar(int ele){
Nodo aux=raiz;
boolean esta=false;
while (aux.sig!=null) {
if(aux.info==ele){
esta=true;
break;
}
aux=aux.sig;
}
return esta;
}
//metodo mas eficiente que el metodo buscar
public boolean buscarSoco(int ele){
Nodo aux=raiz;
boolean esta=false;
while (aux.sig!=null && aux.info!=ele)
aux=aux.sig;
if(aux.info==ele)
esta=true;
return esta;
}
}
14
PROGRAMACION
COLECCIONES
SHEILA NIETO UREÑA
AppMain
package listaInteface;
import java.util.Scanner;
import listas.Lista;
public class AppMain {
//private Nodo;
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
Lista l=new Lista();
int num=0;
//
System.out.print("Introduce numero: ");
//
num=sc.nextInt();
//
l.insertar(num);
for (int i=0;i<5;i++){
num=(int)(Math.random()*25);
l.insertar(num);
}
l.listar();
l.contarNodos();
System.out.println("\nLa lista tiene "+l.contadorNodos()+" nodos");
l.eleMayor();
System.out.print("Introduce el numero a buscar: ");
int ele=sc.nextInt();
if(l.buscar(ele)) //o if(l.buscarSoco(ele))
System.out.println(ele+" esta en la lista");
else
System.out.println(ele+" no esta en la lista");
}
}
sc.close();
15
PROGRAMACION
alumInterface
COLECCIONES
ListaAlum
package alumInterface;
public interface ListaAlum{
}
public abstract void insertar(Alumno ele);
int contar();
int mayor();
Alumno AlumnoMayor();
public void ver();
Alumno
package alumInterface;
public class Alumno {
String nombre;
int edad;
}
public Alumno(){}
public Alumno(String n, int e){
nombre=n;
edad=e;
}
public String toString() {
return "\t"+nombre+", "+edad+" años";
}
ListadoAlum
package alumInterface;
public class ListadoAlum implements ListaAlum{
public class Nodo{
Alumno info;
Nodo sig;
}
private Nodo raiz;
ListadoAlum(){
raiz=null;
}
public void insertar(Alumno ele){
Nodo nuevo=new Nodo();
nuevo.info=ele;
if(raiz==null){
nuevo.sig=null;
raiz=nuevo;
}else{
nuevo.sig=raiz;
raiz=nuevo;
}
}
public int contar(){
Nodo aux=raiz;
int con=0;
if(raiz==null)
System.out.println("Lista vacia");
else{
16
SHEILA NIETO UREÑA
PROGRAMACION
COLECCIONES
while (aux!=null) {
con++;
aux=aux.sig;
}
}
return con;
}
}
public int mayor(){
Nodo aux=raiz;
int mayor=0;
while(aux!=null){
if(aux.info.edad>mayor)
mayor=aux.info.edad;
aux=aux.sig;
}
return mayor;
}
public Alumno AlumnoMayor(){
Alumno a=null;
Nodo aux=raiz;
int mayor=0;
while(aux!=null){
if(aux.info.edad>mayor){
mayor=aux.info.edad; //a.nombre=aux.info.nombre;
a=aux.info;
//a.edad=aux.info.edad;
}
aux=aux.sig;
}
return a;
}
public void menorEdad(ListadoAlum la2){ //crear otra lista
Nodo aux=raiz; //lista original
Nodo aux2=la2.raiz; //nueva lista
System.out.println("Alumnos menores de edad:");
while(aux!=null){
if(aux.info.edad<18){
la2.insertar(aux.info);
}
aux=aux.sig;
}
if(aux2==null)
System.out.println("\tNo hay alumnos menores de edad");
}
public void ver(){
Nodo aux=raiz;
while (aux!=null) {
//System.out.print(aux.info.edad+"\t");
System.out.println(aux.info.toString());
aux=aux.sig;
}
}
17
SHEILA NIETO UREÑA
PROGRAMACION
COLECCIONES
SHEILA NIETO UREÑA
AppMain
package alumInterface;
import java.util.Scanner;
public class AppMain {
static Scanner sc=new Scanner(System.in);
public static void main(String[] args) {
ListadoAlum la=new ListadoAlum();
ListadoAlum la2=new ListadoAlum();
introducirDatos(la);
System.out.println("\nNº elementos que contiene la lista: "+la.contar());
System.out.println("\nEl alumno de mayor edad tiene "+la.mayor()+" años");
System.out.println("\n"+la.AlumnoMayor().nombre+" es el alumno de mayor edad
con "
+la.AlumnoMayor().edad+" años\n");
la.menorEdad(la2);
la2.ver();
System.out.println("\nListado de alumnos:");
la.ver();
sc.close();
}
}
public static void introducirDatos(ListadoAlum la) {
int ele,k,e;
String n;
System.out.print("Introduce numero de elementos a insertar: ");
ele=sc.nextInt();
for (k=0; k<ele; k++) {
sc.nextLine();
System.out.print("\nIntroduce nombre: ");
n=sc.nextLine();
System.out.print("Introduce edad: ");
e=sc.nextInt();
Alumno a=new Alumno(n,e);
la.insertar(a);
}
}
18
PROGRAMACION
PILAS
COLECCIONES
pilas
PilasInterface
package pilas;
public interface PilasInterface {
boolean pilaVacia();
void insertar(int ele);
int extraer(); //elimina el elemento de la pila
int mostrar(); //muestra el ultimo elemento de la pila
}
Pilas
package pilas;
public class Pilas implements PilasInterface {
class Nodo{
int info;
Nodo sig;
}
private Nodo raiz;
public Pilas(){
raiz=null;
}
public boolean pilaVacia(){
if(raiz==null)
return true;
else
return false;
}
public void insertar(int ele) {
Nodo nuevo=new Nodo();
nuevo.info=ele;
if (pilaVacia()){ //si pila esta vacia
nuevo.sig=null;
raiz=nuevo;
}
else{ //si la pila tiene elementos
nuevo.sig=raiz;
raiz=nuevo;
}
}
public int extraer(){ //elimina el elemento de arriba de la pila
int ele;
if(!pilaVacia()){ //si la pila contiene informacion
ele=raiz.info;
raiz=raiz.sig;
return ele;
}
else
//si la pila esta vacia
return Integer.MAX_VALUE;
}
public int mostrar() {
19
SHEILA NIETO UREÑA
PROGRAMACION
}
}
COLECCIONES
int ele;
if(!pilaVacia()){ //si la pila contiene informacion
ele=raiz.info;
}
else
//si la pila esta vacia
ele=Integer.MAX_VALUE;
return ele;
AppPila
package pilas;
public class AppPila {
static int x,y;
}
public static void main(String[] args){
Pilas p=new Pilas();
x=(int)(Math.random()*15);
for(int k=0; k<x; k++){
y=(int)(Math.random()*25);
p.insertar(y);
}
System.out.println("El elemento cima es "+p.mostrar());
while(!p.pilaVacia())
System.out.println(p.extraer()+"\t");
System.out.print(p.mostrar());
}
20
SHEILA NIETO UREÑA
PROGRAMACION
ARRAYLIST
COLECCIONES
SHEILA NIETO UREÑA
arraylist
TablasDinamicas
package arraylist;
import java.util.ArrayList;
public class TablasDinamicas {
public static void main(String[] args) {
ArrayList<Integer> a=new ArrayList<Integer>();
System.out.print("Tamaño del arrayList es "+a.size());
//insertar 5 elementos en el arrayList
for (int k=0; k<5; k++)
a.add(k+2);
//visualizar contenido
System.out.println("\nContenido del ArrayList");
for (int k=0; k<a.size(); k++)
System.out.print(a.get(k)+"\t");
a.add(3,25);
//Se añade un 25 en la posicion 3
a.set(2, 33);
//En la posicion 2 se cambia su valor a 33
System.out.println("\nContenido del arrayList");
for (int k=0; k<a.size(); k++)
System.out.print(a.get(k)+"\t");
//Busqueda de un elemento dentro del arraylist
if(a.contains(14))
System.out.println("\nElemento encontrado");
else
System.out.println("\nElemento 14 NO se ha encontrado");
//Buscar posicion de un elemento del arraylist
System.out.println("\nEl
elemento
25
se
encuentra
en
"+a.indexOf(25));
//Eliminar el elemento que hay en la posicion 4
System.out.println("Eliminar el elemento de la posicion 4");
a.remove(4);
//Visualizar el arraylist con un toString
System.out.println(a);
//Visualizar el arraylist con un foreach
for(Integer k:a)
System.out.print(k+"\t");
}
//Ejemplos de métodos con arraylist
public void suma(ArrayList<Integer>num){
}
public ArrayList<Integer>copiar(ArrayList<Integer>num){
ArrayList<Integer>c=new ArrayList<Integer>();
}
}
return c;
21
la
posicion
PROGRAMACION
COLECCIONES
SHEILA NIETO UREÑA
OrdenarNum
package arraylist;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
public class OrdenarNum {
public static void main(String[] args) {
ArrayList<Integer> num=new ArrayList<Integer>();
int n;
for (int i=0;i<5;i++) {
n=(int)(Math.random()*10);
num.add(n);
}
System.out.print("Datos del arraylist: "+num);
Collections.sort(num);
System.out.print("\nArraylist ordenado de menor a mayor: "+num);
}
}
Comparator<Integer> comparador=Collections.reverseOrder();
Collections.sort(num,comparador);
System.out.print("\nArraylist ordenado de mayor a menor: "+num);
OrdenarCad
package arraylist;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
public class OrdenarCad {
}
public static void main(String[] args) {
ArrayList<String> nom=new ArrayList<String>();
nom.add("Pepe");
nom.add("Juan");
nom.add("Ana");
nom.add("Pilar");
nom.add("Eva");
System.out.print("Listado de nombres: "+nom);
Collections.sort(nom);
System.out.print("\nListado ordenado alfabeticamente: "+nom);
Comparator<String> comparador=Collections.reverseOrder();
Collections.sort(nom,comparador);
System.out.print("\nListado ordenado inversamente: "+nom);
System.out.print("\nListado ordenado inversamente con un foreach\n
for(String n: nom)
System.out.print(n+" ");
System.out.println("]");
}
22
[");
PROGRAMACION
COLECCIONES
SHEILA NIETO UREÑA
Altura (useLocale - printf)
package arraylist;
import java.util.ArrayList;
import java.util.Locale;
import java.util.Scanner;
//Sirve para usar nomenclatura americana. Para usar el
punto del teclado numérico.
public class Altura {
static Scanner sc=new Scanner(System.in).useLocale(Locale.US);
public static int num;
public static double media;
public static void main(String[] args) {
ArrayList<Double> altura=new ArrayList<Double>();
num=numAlum();
altura=leerAltura(altura,num);
media=calcularMedia(altura);
mostrarResultado(altura,media);
sc.close();
}
}
public static int numAlum(){
System.out.print("Introducir nº de alumnos: ");
num=sc.nextInt();
return num;
}
public static ArrayList <Double> leerAltura (ArrayList<Double>a,int num){
ArrayList<Double>c=new ArrayList<Double>();
System.out.println("INTRODUCIR ALTURAS");
for(int i=0; i<num; i++){
int k=i+1;
System.out.print("Alumno "+k+": ");
c.add(sc.nextDouble());
}
return c;
}
public static double calcularMedia(ArrayList<Double>a){
double m=0;
for(int i=0; i<a.size(); i++)
m+=a.get(i);
m=m/a.size();
return m;
}
public static void mostrarResultado(ArrayList<Double>a,double m){
int sup=0,inf=0;
System.out.println("\nLista de alturas: "+a);
for(int i=0; i<a.size(); i++)
if(a.get(i)>m)
sup++;
else
if(a.get(i)<m)
inf++;
System.out.printf("\nMedia: %.2f %n", media); //Expresa la media con 2 decimales
System.out.println("Alumnos por encima de la media: "+sup);
System.out.println("Alumnos por debajo de la media: "+inf);
}
23
PROGRAMACION
COLECCIONES
SHEILA NIETO UREÑA
SumaMedia
package arraylist;
import java.util.ArrayList;
import java.util.Scanner;
public class SumaMedia{
static Scanner sc=new Scanner(System.in);
public static ArrayList <Integer> num=new
public static int suma;
public static double media;
ArrayList<Integer>();
public static void main(String[] args) {
num=leerValores();
suma=calcularSuma(num);
media=(double)suma/num.size();
mostrarResultado(num,suma,media);
}
public static ArrayList <Integer> leerValores(){
ArrayList <Integer> c =new ArrayList<Integer>();
System.out.println("Introducir elementos del ArrayList. "+
"Para parar introducir -99");
int k=0,ele;
do{
System.out.print("Introducir elemento: ");
c.add(sc.nextInt());
ele=c.get(k);
k++;
}while(ele!=-99);
c.remove(k-1);
return c;
}
public static int calcularSuma(ArrayList <Integer> num){
suma=0;
for (int i=0; i<num.size(); i++) {
suma+=num.get(i);
}
return suma;
}
public static void mostrarResultado(ArrayList <Integer> num, int
media){
int con=0;
for (Integer i:num)
if(i>media)
con++;
System.out.println("\nArrayList: "+num);
System.out.printf("Suma: "+suma+"\nMedia: %.2f",media);
System.out.print("\nNº de valores por encima de la media: "+con);
}
}
24
suma,double
PROGRAMACION
coches
COLECCIONES
AppCoches
package coches;
public class AppCoches {
}
public static void main(String[] args) {
Coches ac=new Coches();
ac.meterCoches();
ac.verCoches();
ac.buscarMarca(ac.car);
ac.menosKm(ac.car);
ac.mayorKm(ac.car);
}
Coche
package coches;
public class Coche{
private String matricula;
private String marca;
private String modelo;
private int km;
public Coche(){}
public Coche(String mat,String mar,String mod,int km){
matricula=mat;
marca=mar;
modelo=mod;
this.km=km;
}
}
public String getMat() {
return matricula;
}
public void setMat(String matricula) {
this.matricula = matricula;
}
public String getMar() {
return marca;
}
public void setMar(String marca) {
this.marca = marca;
}
public String getMod() {
return modelo;
}
public void setMod(String modelo) {
this.modelo = modelo;
}
public int getKm() {
return km;
}
public void setKm(int km) {
this.km = km;
}
public String toString() {
return "\nMatricula: "+matricula+"\nMarca: "+marca
+"\nModelo: "+modelo+"\nKm: "+km;
}
25
SHEILA NIETO UREÑA
PROGRAMACION
COLECCIONES
SHEILA NIETO UREÑA
Coches
package coches;
import java.util.ArrayList;
import java.util.Scanner;
public class Coches {
Scanner sc=new Scanner(System.in);
ArrayList<Coche>car=new ArrayList<Coche>();
Coche c;
//
//
//
//
public void meterCoches(){
System.out.print("Nº de vehiculos a introducir: ");
int n=sc.nextInt();
System.out.println("INTRODUCIR VEHICULOS");
for (int i=0;i<n;i++){
c=new Coche();
sc.nextLine();
int j=i+1;
System.out.print("\nVehiculo "+j+"\nIntroduce matricula: ");
c.setMat(sc.nextLine());
System.out.print("Introduce marca: ");
c.setMar(sc.nextLine());
System.out.print("Introduce modelo: ");
c.setMod(sc.nextLine());
System.out.print("Introduce km: ");
c.setKm(sc.nextInt());
car.add(c);
}
}
public void verCoches(){
for(Coche i:car)
System.out.println(i.toString());
System.out.println("----------------------------");
}
public void buscarMarca(ArrayList<Coche>car){
System.out.print("Introducir marca a buscar: ");
String marca=sc.nextLine();
System.out.println("Vehiculos de la marca "+marca);
for (int i=0;i<car.size();i++) {
if(car.get(i).getMar().equals(marca))
System.out.println(car.get(i).toString());
}
for(Coche i:car)
if(i.getMar().equals(marca))
System.out.println(i.toString());
System.out.println("----------------------------");
}
public void menosKm(ArrayList<Coche>car){
System.out.print("Introducir kilometraje: ");
int km=sc.nextInt();
System.out.println("Vehiculos con menos de "+km+" km");
for(Coche i:car)
if(i.getKm()<km)
System.out.println(i.toString());
System.out.println("----------------------------");
}
public void mayorKm(ArrayList<Coche>c){
int max=0,j=0,k=0;
for(Coche i:car){
if(i.getKm()>max){
max=i.getKm();
k=j;
26
PROGRAMACION
COLECCIONES
}
j++;
}
}
}
System.out.println("Vehiculo con mayor kilometraje");
System.out.println(car.get(k).toString());
INTERFAZ COMPARABLE
persona
Persona
package comparablePersona;
public class Persona implements Comparable<Persona>{
String nombre;
int edad;
public Persona(){}
public Persona(String n,int edad){
nombre=n;
this.edad=edad;
}
//ORDENA POR NOMBRE
public int compareTo(Persona p) {
Persona pers=(Persona)p;
return nombre.compareTo(pers.getNombre());
}
//ORDENA POR EDAD
// public int compareTo(Persona o) {
//
if (edad<o.edad)
//
return -1;
//
if (edad>o.edad)
//
return 1;
//
return 0;
// }
}
public String toString() {
return nombre+", "+edad+" años";
}
public String getNombre() {
return nombre;
}
public void setNombre(String nombre) {
this.nombre = nombre;
}
public int getEdad() {
return edad;
}
public void setEdad(int edad) {
this.edad = edad;
}
27
SHEILA NIETO UREÑA
PROGRAMACION
COLECCIONES
OrdenarPers
package comparablePersona;
import
import
import
import
import
java.util.ArrayList;
java.util.Collections;
java.util.Comparator;
java.util.Iterator;
java.util.List;
public class OrdenarPersona {
public static void main(String[] args) {
List<Persona>pers=new ArrayList<Persona>();
Persona p1=new Persona("Zipi",13);
Persona p2=new Persona("Zape",13);
pers.add(p1);
pers.add(p2);
pers.add(new Persona("El Súper",55));
pers.add(new Persona("Filemón",41));
pers.add(new Persona("Mortadelo",40));
}
}
System.out.println("\nLISTADO ORIGINAL");
ver(pers);
System.out.println("\nLISTADO ORDENADO");
Collections.sort(pers);
ver(pers);
System.out.println("\nINVERSAMENTE ORDENADO");
Comparator<Persona>c=Collections.reverseOrder();
Collections.sort(pers,c);
ver(pers);
public static void ver(List<Persona> lista) {
Iterator<Persona>it=lista.iterator();
while(it.hasNext())
System.out.println(it.next());
}
articulo
Articulo
package comparableArticulo;
public class Articulo implements Comparable<Articulo>{
private String nombre;
private double valor;
public Articulo(String n,double valor){
nombre=n;
this.valor=valor;
}
//ORDENA POR NOMBRE
public int compareTo(Articulo o) {
Articulo art=(Articulo)o;
return nombre.compareTo(art.getNombre());
}
28
SHEILA NIETO UREÑA
PROGRAMACION
COLECCIONES
SHEILA NIETO UREÑA
//ORDENA POR VALOR
// public int compareTo(Articulo o) {
//
if (valor<o.valor)
//
return -1;
//
if (valor>o.valor)
//
return 1;
//
return 0;
// }
//ORDENA POR NOMBRE Y LUEGO POR VALOR
// public int compareTo(Articulo o){
//
Articulo art=(Articulo)o;
//
if(nombre.compareToIgnoreCase(art.getNombre())==0){
//
if (valor<o.valor)
//
return -1;
//
if (valor>o.valor)
//
return 1;
//
return 0;
//
}
//
else
//
return nombre.compareTo(art.getNombre());
// }
//GETTERS Y SETTERS
}
AppArticulo
package comparableArticulo;
import
import
import
import
java.util.ArrayList;
java.util.Collections;
java.util.Comparator;
java.util.Iterator;
public class OrdenarArticulo {
public static void main(String[] args) {
ArrayList<Articulo>art=new ArrayList<Articulo>();
art.add(new Articulo("Cuaderno peque",0.99));
art.add(new Articulo("BIC
",0.22));
art.add(new Articulo("Cuaderno grande",2.29));
art.add(new Articulo("Post-it ",7.39));
art.add(new Articulo("Lápiz
",0.75));
art.add(new Articulo("Lápiz
",0.15));
System.out.println("\nLISTADO ORIGINAL");
ver(art);
System.out.println("\nLISTADO ORDENADO");
Collections.sort(art);
ver(art);
System.out.println("\nINVERSAMENTE ORDENADO");
Comparator<Articulo>c=Collections.reverseOrder();
Collections.sort(art,c);
ver(art);
}
}
System.out.println("------------------------------------------------------");
System.out.println("El artículo más caro es el "+Collections.max(art));
System.out.println("El artículo más barato es el "+Collections.min(art));
public static void ver(ArrayList<Articulo> art) {
Iterator<Articulo>it=art.iterator();
while(it.hasNext())
System.out.println(it.next());
}
29
PROGRAMACION
calificaciones
COLECCIONES
SHEILA NIETO UREÑA
Alumno
package comparableCalificaciones;
import java.util.ArrayList;
import java.util.Scanner;
public class Alumno implements Comparable<Alumno> {
Scanner sc=new Scanner(System.in);
private String nombre;
private int nota1;
private int nota2;
private int nota3;
double media;
public Alumno(){}
public Alumno(String nom,int n1,int n2,int n3){
nombre=nom;
nota1=n1;
nota2=n2;
nota3=n3;
}
//
//
//
//
//
public int compareTo (Alumno o){
Alumno otroAlum=(Alumno) o;
return nombre.compareToIgnoreCase(otroAlum.getNombre());
}
public ArrayList<Alumno> pedirDatos(){
ArrayList<Alumno>lista=new ArrayList<Alumno>();
Alumno a;
System.out.print("Introcucir nº de alumnos: ");
int n=sc.nextInt();
for (int i=0;i<n;i++){
a=new Alumno();
sc.nextLine();
int j=i+1;
System.out.print("Alumno "+j);
System.out.print("\n
Introduce nombre: ");
a.nombre=sc.nextLine();
System.out.print(" Introduce nota 1: ");
a.setNota1(sc.nextInt());
System.out.print(" Introduce nota 2: ");
a.setNota2(sc.nextInt());
System.out.print(" Introduce nota 3: ");
a.setNota3(sc.nextInt());
lista.add(a);
}
return lista;
}
public void verAlumnos(ArrayList<Alumno>al){
//FOR-EACH
for(Alumno i:al)
System.out.println(i.toString());
System.out.println("----------------------------");
}
public void verAlumnos(ArrayList<Alumno>al){
//ITERATOR
Iterator<Alumno> it=al.iterator();
while(it.hasNext())
System.out.println(it.next());
}
public ArrayList<Double> mediaAlum(ArrayList<Alumno>al){
ArrayList<Double>med=new ArrayList<Double>();
30
PROGRAMACION
COLECCIONES
SHEILA NIETO UREÑA
for(int i=0;i<al.size();i++){
media=0;
media=(double)(al.get(i).nota1+al.get(i).nota2+al.get(i).nota3)/3;
med.add(media);
}
return med;
}
}
public void mediaTotal(ArrayList<Alumno>al,ArrayList<Double>med){
double media=0;
for (int i=0;i<med.size();i++)
media+=med.get(i);
media=media/med.size();
System.out.printf("NOTA MEDIA TOTAL: %.2f %n",media);
System.out.println("----------------------------");
}
public void buscarNom(ArrayList<Alumno>al){
System.out.print("Introduce alumno a buscar: ");
String nom=sc.next();
nom=nom.toUpperCase();
int k=0;
for(int i=0;i<al.size();i++){
if(nom.compareToIgnoreCase(al.get(i).getNombre())==0){
System.out.println(nom+" sí pertenece al centro");
k++;
}
}
if(k==0)
System.out.println(nom+" no es alumno/a del centro");
}
public String getNombre() {
return nombre;
}
public void setNombre(String nombre) {
this.nombre = nombre;
}
public int getNota1() {
return nota1;
}
public void setNota1(int nota1) {
this.nota1 = nota1;
}
public int getNota2() {
return nota2;
}
public void setNota2(int nota2) {
this.nota2 = nota2;
}
public int getNota3() {
return nota3;
}
public void setNota3(int nota3) {
this.nota3 = nota3;
}
@Override
public String toString() {
return "\nAlumno: "+nombre+"\n
Nota 1: "+nota1+"\n
Nota 2: "
+ nota2+"\n
Nota 3: "+nota3;
}
31
PROGRAMACION
COLECCIONES
SHEILA NIETO UREÑA
OrdenarNota
package comparableCalificaciones;
import java.util.Comparator;
public class OrdenarNota implements Comparator<Object>{
public int compare(Object o1,Object o2){
Alumno a1=(Alumno)o1;
Alumno a2=(Alumno)o2;
int res=Integer.compare(a1.getNota1(), a2.getNota1());
return res;
}
}
AppAlumno
package comparableCalificaciones;
import java.util.ArrayList;
import java.util.Collections;
public class AppCalificaciones {
//
//
//
//
//
//
//
//
}
public static void main(String[] args) {
Alumno a=new Alumno();
ArrayList<Alumno>al=new ArrayList<Alumno>();
ArrayList<Double>medAlum=new ArrayList<Double>();
al=a.pedirDatos();
Alumno a1=new
Alumno a2=new
Alumno a3=new
Alumno a4=new
al.add(a1);
al.add(a2);
al.add(a3);
al.add(a4);
}
Alumno("Pepe",6,7,8);
Alumno("Pepe",5,4,5);
Alumno("Ana",2,4,5);
Alumno("Eva",9,7,8);
System.out.print("LISTADO ORIGINAL");
a.verAlumnos(al);
medAlum=a.mediaAlum(al);
System.out.println("NOTA MEDIA POR ALUMNO");
for (int i=0;i<medAlum.size();i++)
System.out.printf(" "+al.get(i).getNombre()+": %.2f %n", medAlum.get(i));
System.out.println("----------------------------");
a.mediaTotal(al,medAlum);
Collections.sort(al);
System.out.println("LISTADO ORDENADO POR NOMBRE\n"+al);
System.out.println("----------------------------");
Collections.sort(al, new OrdenarNota());
System.out.println("LISTADO ORDENADO POR NOTA 1\n"+al);
System.out.println("----------------------------");
a.buscarNom(al);
System.out.println("----------------------------");
System.out.printf("MAYOR NOTA MEDIA: %.2f %n",Collections.max(medAlum));
System.out.printf("MENOR NOTA MEDIA: %.2f %n",Collections.min(medAlum));
32
PROGRAMACION
LIST, LINKEDLIST, SET
COLECCIONES
SHEILA NIETO UREÑA
list
ClaseList
package list;
import
import
import
import
java.util.ArrayList;
java.util.Iterator;
java.util.LinkedList;
java.util.List;
public class ClaseList {
}
public static void main(String[] args) {
List <Integer> lista =new ArrayList <Integer>();
List <Double> reales =new ArrayList <Double>();
LinkedList <Double> reals =new LinkedList <Double>();
//LIST
lista.add(8);
lista.add(new Integer (3));
// lista.add(9, 0); mal, no deja espacios en blanco hasta la posicion 9
lista.add(0,9);
Iterator<Integer> it=lista.iterator();
System.out.println("Listado nº enteros");
while (it.hasNext())
System.out.print(it.next()+"\t");
System.out.println("\n---------------------------------");
//ARRAYLIST
reales.add(0,8.9);
reales.add(new Double (3.4));
reales.add(7.4);
System.out.println("Listado nº reales");
for (Double i:reales){
System.out.print(i+"\t");
}
System.out.println("\n---------------------------------");
if (lista.isEmpty())
System.out.println("Lista vacia");
else
System.out.println("El nº de elementos de la lista: "+reales.size());
System.out.println("---------------------------------");
//LINKEDLIST
reals.add(2.1);
reals.add(new Double (3.4));
reals.add(0,7.3);
Iterator<Double>i=reals.iterator();
System.out.println("Listado nº reales");
while (i.hasNext())
System.out.print(i.next()+"\t");
System.out.println("\nPrimer elemento de la lista: "+reals.getFirst());
System.out.println("Ultimo elemento de la lista: "+reals.getLast());
}
33
PROGRAMACION
set
COLECCIONES
SHEILA NIETO UREÑA
Frutas
package set;
import
import
import
import
java.util.Arrays;
java.util.Iterator;
java.util.Set;
java.util.TreeSet;
public class Frutas {
public static void main(String[] args) {
String fruta[]={"uvas","limones","manzanas","peras","fresas","peras","uvas"};
Set<String>frutas=new TreeSet<String>();
System.out.println("ORIGINAL");
for(int i=0;i<fruta.length;i++)
System.out.print("
"+fruta[i]);
}
}
System.out.println("\n\nORDENADO Y SIN REPETICION");
frutas.addAll(Arrays.asList(fruta));
Iterator<String>it=frutas.iterator();
while(it.hasNext())
System.out.print("
"+it.next());
34