Java: Dominando las Collections - Notas
ArrayList Si tenemos una lista de tipo String llamada alumnos, ¿cuál sería el método y valor para adicionar de forma correcta a la lista sin errores de compilación? Seleccione una alternativa alumnos.add(“Pepito”); ¡Alternativa correcta! El método correcto es add y estamos colocando un String dentro del método add.
Si tenemos una lista de String llamada alumnos, ¿cómo recorremos todos los valores de esa lista? Seleccione una alternativa for ( String alumno : alumnos) { /*---------*/ } ¡Alternativa correcta! Estoy usando un for recibiendo valores String.
Queremos imprimir de forma descendente una lista de String llamada alumnos ¿cuál sería la forma de poder hacerlo?
Seleccione una alternativa
Collections.sort(alumnos, Collections.reverseOrder());
¡Alternativa correcta! El método reverseOrder hace que nuestra lista sea ordenada descendentemente.
En nuestra Clase3.java vamos adicionar el siguiente código para ordenar de forma descendente:
List cursosList = cursos.stream().sorted(Comparator.reverseOrder()).collect(Collectors.toList());
System.out.println(cursosList);
Lo que aprendimos en esta aula:
Introducción de Listas.
Diferencias entre un Array[] e ArrayList.
Adicionar valores en un ArrayList usando el método add().
Remover valores de un ArrayList usando el método remove().
Leer una lista usando for, foreach o foreach de Java 8 usando lambda.
Uso de la clase Collections para ordenar una lista simple.
Ordenar una lista usando el método sort() de la clase Collections.
Uso del método sort() de una lista.
Ordenar una lista usando stream().
Pero yo no quiero esto, yo quiero solamente por ejemplo colocar el nombre del curso. Entonces para esto vamos a hacer aquí implementar el override y aquí implementar el public, el método toString. Entonces aquí estoy sobrescribiendo el método toString que ya viene por defecto en todas las clases. Solamente que si no lo utilizo, él va a imprimir el toString del objeto que yo estoy creando, por eso aparecen esos valores extraños que ustedes están viendo o que nosotros vimos. @Override // Sobreescribimos en la clase deseada public String toString(){ return this.nombre; }
Queremos añadir un nuevo curso a nuestra lista de Curso ¿cuál sería la forma de poder hacerlo?
Curso curso1 = new Curso("Geometria",30) ;
ArrayList
Queremos ordenar una lista descendentemente por el tiempo de duración de Cursos con atributos que se llaman nombre y tiempo ¿Cuál sería la forma de poder hacerlo?
Curso curso1 = new Curso("PHP",30) ;
Curso curso2 = new Curso("Ruby",10) ;
Curso curso3 = new Curso("JavaScript",20) ;
Curso curso4 = new Curso("Java",50) ;
ArrayList cursos = new ArrayList<>();
cursos.add(curso1);
cursos.add(curso2);
cursos.add(curso3);
cursos.add(curso4);
Seleccione una alternativa
Collections.sort(cursos,Comparator.comparing(Curso::getTiempo).reversed());
¡Alternativa correcta! Estoy ordenando la lista por tiempo de forma descendente, por eso es la respuesta correcta.
Llegó el momento de que tú mismo ejecutes todos los pasos que hemos realizado durante esta aula. Si ya lo has hecho, ¡excelente!. Si no, es importante que realices lo que enseñé en los videos para continuar con la próxima aula.
En nuestra Clase5.java vamos ordenar nuestra lista por nombre descendentemente de cursos excluyendo PHP:
List cursoList = cursos.stream().filter(curso -> !curso.getNombre().equalsIgnoreCase("PHP")).sorted(Comparator.comparing(Curso::getNombre).reversed()).collect(Collectors.toList());
System.out.println(cursoList);
Lo que aprendimos en esta aula: Crear una lista usando una clase llamada Curso. Sobrescribir el método toString de una clase para imprimir los valores de la clase Curso. Ordenar la lista de Cursos usando la clase Collections. Ordenar una lista de Cursos usando el método comparing de la clase Comparator, para seleccionar el tipo de atributo que usaremos para ordenar. Uso de stream() en nuestra lista de Cursos. Filtrar una lista usando el método filter() de stream. Usar stream para crear una nueva filtrada y ordenada usando el método collect().
¿Cuál no es un tipo de List? HashSet ¡Alternativa correcta! Es una implementación de la interfaz Set y no de List
listas Clase 7
package com.alura;
import com.alura.model.Aula;
import com.alura.model.Curso;
import java.util.ArrayList;
import java.util.List;
public class Clase7 {
public static void main(String[] args) {
Curso curso1 = new Curso("Java",30) ;
curso1.addAula(new Aula("ArrayList"));
curso1.addAula(new Aula("List"));
curso1.addAula(new Aula("LinkedList"));
curso1.addAula(new Aula("Inmutable"));
List< Aula> aulaList = curso1.getAulaList();
ArrayList< Curso> cursos = new ArrayList<>();
cursos.add(curso1);
System.out.println(aulaList);
}
}
¿Cómo crear una lista de ArrayList? Seleccione una alternativa List lista = new ArrayList<>(); ¡Alternativa correcta! Estoy creando un List( Interfaz) que está implementando un ArrayList.
LinkedList Clase 8
package com.alura;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
public class Clase8 {
public static final List> listas = new ArrayList>(){
{
add(new LinkedList<>());
add(new ArrayList<>());
}
};
public static void main(String[] args) {
for(List lista : listas){
final String nombreImplementacion = lista.getClass().getSimpleName();
//add
long inicio = System.currentTimeMillis(); // Vemos el tiempo transcurrido
for (int i=0; i < 100000; i++){
lista.add(i);
}
long fin = System.currentTimeMillis();
long duracion = fin - inicio;
System.out.println(nombreImplementacion + " add: " + duracion);
//get
inicio = System.currentTimeMillis();
for(int i = 0; i < 100000; i++){
lista.get(i);
}
fin = System.currentTimeMillis();
duracion = fin - inicio;
System.out.println(nombreImplementacion + " get: " + duracion);
//remove
inicio = System.currentTimeMillis();
for(int i = 99999; i >= 0; i--){
lista.remove(i);
}
fin = System.currentTimeMillis();
duracion = fin - inicio;
System.out.println(nombreImplementacion + " remove: " + duracion);
//LINKEDLIST A <-> B1 <-> B2 <-> C <-> D
// Crea una relación entre ellas, las entrelaza.
// LinkedList add: 15 -> El add un poco más
// LinkedList get: 5742 -> El get tarda más
// LinkedList remove: 4 -> Los remove casi iguales
// ArrayList add: 6
// ArrayList get: 4
// ArrayList remove: 4
//ARRAYLIST A -> B1 -> B -> C -> D
// El arraylist solo lo hace en un sentido.
// Entonces cada uno tiene sus ventajas, pero por eso también estuvimos viendo utilizar las interfaces.
// ¿Por qué? Porque imaginémonos que ya tenemos una lista, ya tenemos el sistema y utilizamos ArrayList y vemos que está demorando bastante. ¿Qué hacemos? Vamos a cambiarlo para el LinkedList.
// La parte de adicionar las posiciones está demorando bastante, entonces cambiamos para LinkedList. Y automáticamente toda nuestra lista se convirtió en LinkedList. Por eso es una gran ventaja trabajar prácticamente con nuestra interface lista y todas las implementaciones que usemos, las podemos cambiar de aquí a un tiempo.
}
}
}
¿Cuál es una de las principales diferencias entre un ArrayList y LinkedList? El método get es más rápido usando ArrayList que LinkedList. ¡Alternativa correcta! Al usar ArrayList, al guardar la posición termina siendo más rápido que un LinkedList.
Crear una lista dentro de una lista de Objetos y obtener los valores de esa sublista usando el método get. Obtener una lista inmutable usando el método unmodifiableList de la clase Collections. Ver cómo funcionan las referencias entre listas. Adicionar valores a una sublista usando el método add(). Ver que la principal diferencia de un LinkedList y ArrayList es que un LinkedList termina siendo más rápido para adicionar valores a una lista en cualquier posición, a diferencia de una ArrayList donde dependiendo de la posición que sea adicionado el valor y dependiendo del tamaño de la lista va terminar siendo más demorado. Además usando el método get() para obtener algún valor de una posición de un LinkedList termina siendo más demorado que un ArrayList. Usar un ejemplo práctico para ver esas diferencias en tiempo de ejecución y tomar nuestras propias conclusiones.
Collections y Streams Clase 9
package com.alura;
import com.alura.model.Curso;
import java.util.*;
import java.util.stream.Collectors;
public class Clase9 {
public static final List> listas = new ArrayList>(){
{
add(new LinkedList<>());
add(new ArrayList<>());
}
};
public static void main(String[] args) {
Curso curso1 = new Curso("Historia",30) ;
Curso curso2 = new Curso("Algebra",10) ;
Curso curso3 = new Curso("Aritmetica",20) ;
Curso curso4 = new Curso("Geometria",50) ;
ArrayList cursos = new ArrayList<>();
cursos.add(curso1);
cursos.add(curso2);
cursos.add(curso3);
cursos.add(curso4);
//System.out.println(cursos);
Collections.sort(cursos,Comparator.comparing(Curso::getNombre).reversed());
int suma = 0;
for(Curso curso: cursos){
if(!curso.getNombre().equalsIgnoreCase("Historia")) {
suma += curso.getTiempo();
}
}
System.out.println(suma);
//System.out.println(cursos);
List cursoList = cursos.stream().filter(curso -> !curso.getNombre().equalsIgnoreCase("Ruby")).sorted(Comparator.comparingInt(Curso::getTiempo)).collect(Collectors.toList());
System.out.println(cursos.stream().filter(curso -> !curso.getNombre().equalsIgnoreCase("Historia")).mapToInt(Curso::getTiempo).sum());
}
}
¿Cuál método es utilizado para ordenar una lista? sort(..) ¡Alternativa correcta! Método usado para ordenar listas.
De los siguientes métodos ¿Cuáles pertenecen a la interfaz Stream? Seleccione una alternativa filter, findAny, findFirst, mapToInt, map, max, min, anyMatch ¡Alternativa correcta! Todos estos métodos pertenecen a la interfaz Stream.
En nuestra Clase10.java vamos a modificar el curso de Quimica que esta repetido con valor tiempo de 70: Curso curso7 = new Curso("Literatura",70) ; Luego vamos a sumar todos los tiempos de todos los cursos a excepción de Geometria: System.out.println(cursos.parallelStream().filter(curso -> !curso.getNombre().equalsIgnoreCase("Geometria")).mapToInt(Curso::getTiempo).sum()); Ordenar valores de una lista usando la clase Collections. Filtrar valores de una lista usando un for. Sumar valores de una lista usando un for. Usar el método filter() de stream() para buscar o excluir valores de una lista. Utilizar el método mapToInt() de stream() para obtener valores específicos de alguna variable int y sumar esos valores usando el método sum(). Aprender cómo usar los métodos average(), max(), min() de un stream() para obtener diferentes tipos de resultados. Hacer un group by de una lista usando el método groupingBy de la clase Collectors.
clase 10
package com.alura;
import com.alura.model.Curso;
import java.util.*;
import java.util.stream.Collector;
import java.util.stream.Collectors;
public class Clase10 {
public static final List< List< Integer>> listas = new ArrayList< List< Integer>>(){
{
add(new LinkedList<>());
add(new ArrayList<>());
}
};
public static void main(String[] args) {
Curso curso1 = new Curso("Historia",30) ;
Curso curso2 = new Curso("Algebra",10) ;
Curso curso3 = new Curso("Aritmetica",20) ;
Curso curso4 = new Curso("Geometria",50) ;
Curso curso5 = new Curso("Fisica",60) ;
Curso curso6 = new Curso("Quimica",80) ;
Curso curso7 = new Curso("Quimica",70) ;
Curso curso8 = new Curso("Fisica",30) ;
ArrayList< Curso> cursos = new ArrayList<>();
cursos.add(curso1);
cursos.add(curso2);
cursos.add(curso3);
cursos.add(curso4);
cursos.add(curso5);
cursos.add(curso6);
cursos.add(curso7);
cursos.add(curso8);
List< Curso> cursoList = cursos.stream().filter(curso -> !curso.getNombre().equalsIgnoreCase("Ruby")).sorted(Comparator.comparingInt(Curso::getTiempo)).collect(Collectors.toList());
System.out.println(cursos.stream().filter(curso -> !curso.getNombre().equalsIgnoreCase("Historia")).mapToInt(Curso::getTiempo).sum());
// Para obtener el promedio
System.out.println(cursos.stream().mapToInt(Curso::getTiempo).average().getAsDouble());
// El max
System.out.println(cursos.stream().mapToInt(Curso::getTiempo).max().getAsInt());
// El min
System.out.println(cursos.stream().mapToInt(Curso::getTiempo).min().getAsInt());
// Creamos un mapa con una lista de curso, agrupamos
Map< String, List> groupCurso = cursos.stream().collect(Collectors.groupingBy(Curso::getNombre));
// Recorremos el key el value sera los agrupados, los repetidos.
groupCurso.forEach((key , value) -> System.out.println(key + " - " + value.size()));
// ParallelStream
System.out.println(cursos.parallelStream().mapToInt(Curso::getTiempo).sum());
}
}
Clase 11 Collection -> Set -> List -> Queue -> Deque -> SortedSet Map -> SortedMap * El set, no tiene orden es como un círculo donde se van agregando dentro los datos necesarios, no tendremos un orden espécifico ni una posición equivalente. ¿Cuál clase no pertenece a la interfaz Set? ArrayList ¡Alternativa correcta! Es una implementación de la interfaz List y no de Set. En Set, pertenece TreeSet, HashSet y LinkedHashSet
package com.alura;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Set;
public class Clase11 {
// TODO: https://docs.oracle.com/javase/tutorial/collections/interfaces/index.html
// TODO: https://docs.oracle.com/javase/8/docs/api/index.html?java/util/Collection.html
public static void main(String[] args) {
String alumno1 = "Luis Miguel";
String alumno2 = "Pepito los palotes";
String alumno3 = "Juan Carlos";
String alumno4 = "Pedro Pedrito";
String alumno5 = "Gustavo Sanchez";
String alumno6 = "Marcia Maria";
// Usamos la interface set del grupo de las collecitons
// HashSet equivale a un arrarlist
Set< tring> listaAlumnos = new HashSet<>();
listaAlumnos.add(alumno1);
listaAlumnos.add(alumno2);
listaAlumnos.add(alumno3);
listaAlumnos.add(alumno4);
listaAlumnos.add(alumno5);
listaAlumnos.add(alumno6);
// Recorremos el set
for (String alumno: listaAlumnos) {
System.out.println(alumno);
}
}
}
Clase 12
El Set:
- No tiene un orden especifico
- Los valores repetidos no se contemplan
- Acá no podemos usar el .get
- Si podemos recorrerlo con un foreach.
listaAlumnos.forEach(alumno -> {
System.out.println(alumno);
});
// Podemos importar desde la clase Collection, ya que todo viene de Collection.
Collection
clase 12
package com.alura;
import java.util.*;
public class Clase12 {
// TODO: https://docs.oracle.com/javase/tutorial/collections/interfaces/index.html
// TODO: https://docs.oracle.com/javase/8/docs/api/index.html?java/util/Collection.html
public static void main(String[] args) {
String alumno1 = "Luis Miguel";
String alumno2 = "Pepito los palotes";
String alumno3 = "Juan Carlos";
String alumno4 = "Pedro Pedrito";
String alumno5 = "Gustavo Sanchez";
String alumno6 = "Marcia Maria";
String alumno7 = "Marcia Maria";
String alumno8 = "Gustavo Sanchez";
// Podemos importar desde la clase Collection
Collection< String> listaAlumnos = new HashSet<>();
listaAlumnos.add(alumno1);
listaAlumnos.add(alumno2);
listaAlumnos.add(alumno3);
listaAlumnos.add(alumno4);
listaAlumnos.add(alumno5);
listaAlumnos.add(alumno6);
listaAlumnos.add(alumno7);
listaAlumnos.add(alumno8);
listaAlumnos.forEach(alumno -> {
System.out.println(alumno);
});
}
}
¿Cuál es una afirmación correcta al hablar de la interfaz Set? Seleccione una alternativa No guarda objetos duplicados ¡Alternativa correcta! Una de las principales ventajas es cuando adicionamos registros a un Set el no guarda registros duplicados.
interface Set Clase 13
package com.alura;
import java.util.Collection;
import java.util.Comparator;
import java.util.HashSet;
public class Clase13 {
// TODO: https://docs.oracle.com/javase/tutorial/collections/interfaces/index.html
// TODO: https://docs.oracle.com/javase/8/docs/api/index.html?java/util/Collection.html
public static void main(String[] args) {
String alumno1 = "Luis Miguel";
String alumno2 = "Pepito los palotes";
String alumno3 = "Juan Carlos";
String alumno4 = "Pedro Pedrito";
String alumno5 = "Gustavo Sanchez";
String alumno6 = "Marcia Maria";
String alumno7 = "Marcia Maria";
String alumno8 = "Gustavo Sanchez";
Collection< String> listaAlumnos = new HashSet<>();
listaAlumnos.add(alumno1);
listaAlumnos.add(alumno2);
listaAlumnos.add(alumno3);
listaAlumnos.add(alumno4);
listaAlumnos.add(alumno5);
listaAlumnos.add(alumno6);
listaAlumnos.add(alumno7);
listaAlumnos.add(alumno8);
//listaAlumnos.forEach(alumno -> {
// System.out.println(alumno);
//});
// Buscamos si el alumno indicado existe.. El string debe ser tal cual
boolean valida = listaAlumnos.contains("Pedro pedrito");
System.out.println(valida); // true
// Tamaño del String, cual tiene mayor cantidad de letras.
String max = listaAlumnos.stream().max(Comparator.comparingInt(String::length)).get();
System.out.println(max); // Pepito los palotes
System.out.println(max.length()); // 18
// Eliminamos si fuese necesario, si no lo encuentra, no lo elimina..
listaAlumnos.removeIf(alumno -> "Pedro Pedrita".equalsIgnoreCase(alumno));
listaAlumnos.forEach(alumno -> { // Verificamos si se elimino
System.out.println(alumno);
});
}
}
Del siguiente código ¿Cuál sería el resultado al imprimir cada uno de ellos?
String alumno1 = "Luis Miguel";
String alumno2 = "Pepito los palotes";
String alumno3 = "Juan Carlos";
String alumno4 = "Pedro Pedrito";
String alumno5 = "Gustavo sanchez";
String alumno6 = "Marcia Maria";
String alumno7 = "Marcia Maria";
String alumno8 = "Gustavo Sanchez";
Collection
En nuestra Clase13.java vamos a buscar por el nombre Gustavo Polar, como ese nombre no existe vamos a devolver como resultado No existe: System.out.println(listaAlumnos.stream().filter(alumno -> alumno.equalsIgnoreCase("Gustavo Polar")).findFirst().orElse("No Existe"));
Usar un HashSet adicionando valores en un Set de String usando el método add(). Leer un HashSet e imprimir sus valores en consola. Entender el árbol de jerarquías de la Clase Collection. Usar la interfaz Collection para generalizar una lista de HashSet así luego de acuerdo a las necesidades migrar de Set para List. Utilizar el método max() de Stream para obtener el valor máximo de una lista. Usar el método removeIf() de nuestra interfaz Collection. Explicar algunas diferencias entre las interfaces Set y List, en la cual la principal sería que un Set no adiciona valores repetidos.
Clase 14
Creamos una clase para Alumno
Si usamos HashSet, debemos asegurarnos de usar hashCode en nuestra clase padre, sobrescribir.. Van de la mano
@Override
public boolena equals(Object obj){
Alumno alumno = (Alumno) obj;
// Usar los 2 del mismo tipo en el cual estamos comparando
return this.nombre.equals(alumno.getNombre());
}
@Override
public void hashCode(){
// Usar los 2 del mismo tipo en el cual estamos comparando
return this.nombre.hashCode();
}
Ahora sí desde nuestra clase instanciada..
Collection listaAlumnos = new HashSet<>();
clase 14
package com.alura;
import com.alura.model.Alumno;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Comparator;
import java.util.HashSet;
public class Clase14 {
// TODO: https://docs.oracle.com/javase/tutorial/collections/interfaces/index.html
// TODO: https://docs.oracle.com/javase/8/docs/api/index.html?java/util/Collection.html
public static void main(String[] args) {
// Crear objetos a partir del Alumno
Alumno alumno1 = new Alumno("Luis Miguel", "001");
Alumno alumno2 = new Alumno("Pepito los palotes", "002");
Alumno alumno3 = new Alumno("Juan Carlos", "003");
Alumno alumno4 = new Alumno("Pedro Pedrito", "004");
Alumno alumno5 = new Alumno("Gustavo Sanchez", "005");
Alumno alumno6 = new Alumno("Marcia Maria", "006");
Alumno alumno7 = new Alumno("Claudia Patricia", "007");
Collection< Alumno> listaAlumnos = new HashSet<>();
listaAlumnos.add(alumno1);
listaAlumnos.add(alumno2);
listaAlumnos.add(alumno3);
listaAlumnos.add(alumno4);
listaAlumnos.add(alumno5);
listaAlumnos.add(alumno6);
listaAlumnos.add(alumno7);
Alumno alumnoNuevo = new Alumno("Luis Miguel", "001");
System.out.println(alumno1.equals(alumnoNuevo));
System.out.println(listaAlumnos.contains(alumnoNuevo));
}
}
¿Por qué sobrescribir el método equals y hashCode, en una clase?
Seleccione una alternativa
Porque al usar el método contains usa el hashCode y el equals es usado para comparar valores, es una necesidad primordial sobrescribir estos métodos, para buscar los resultados esperados en nuestras comparaciones
¡Alternativa correcta! Aparte de los descrito en la respuesta, es bueno hacer esa sobrescritura de métodos, para luego tener la capacidad de migrar para alguna otra interfaz sin la mayor preocupación de obtener resultados no esperados.
hashCode Clase 15 Como el set no tiene un orden específico.. Con el hashCode subagrupamos en pequeños contenedores.
package com.alura;
import com.alura.model.Alumno;
import com.alura.model.Curso;
import java.util.Collection;
import java.util.HashSet;
public class Clase15 {
// TODO: https://docs.oracle.com/javase/tutorial/collections/interfaces/index.html
// TODO: https://docs.oracle.com/javase/8/docs/api/index.html?java/util/Collection.html
public static void main(String[] args) {
Curso curso1 = new Curso("Historia",30) ;
Alumno alumno1 = new Alumno("Luis Miguel", "001");
Alumno alumno2 = new Alumno("Pepito los palotes", "002");
Alumno alumno3 = new Alumno("Juan Carlos", "003");
Alumno alumno4 = new Alumno("Pedro Pedrito", "004");
Alumno alumno5 = new Alumno("Gustavo Sanchez", "005");
Alumno alumno6 = new Alumno("Marcia Maria", "006");
Alumno alumno7 = new Alumno("Claudia Patricia", "007");
curso1.addAlumno(alumno1);
curso1.addAlumno(alumno2);
curso1.addAlumno(alumno3);
curso1.addAlumno(alumno4);
curso1.addAlumno(alumno5);
curso1.addAlumno(alumno6);
curso1.addAlumno(alumno7);
Alumno alumnoNuevo = new Alumno("Luis Miguel", "001");
System.out.println(alumno1.equals(alumnoNuevo));
System.out.println(curso1.verificaAlumno(alumnoNuevo));
}
}
¿Qué método podemos usar para buscar valores en un HashSet? Seleccione una alternativa contains(....) ¡Alternativa correcta! El método contains nos permite buscar un valor en nuestro HashSet.
En nuestra Clase15.java imprimir todos los códigos de los alumnos de forma descendente para el curso1: curso1.getAlumnos().stream().sorted(Comparator.comparing(Alumno::getCodigo).reversed()).forEach(alumno -> System.out.println(alumno.getCodigo()));
Es muy importante sobrescribir el método equals y hashCode de un Set porque así podremos usar con efectividad nuestros métodos contains() y comparar valores usando el método equals. Verificar valores de un Set. Encapsular métodos para adicionar valores de una Lista de Set o List para poder hacer una migración de tipo de lista con más facilidad.
Clase 16
package com.alura;
import com.alura.model.Alumno;
import com.alura.model.Curso;
import java.util.Iterator;
public class Clase16 {
// TODO: https://docs.oracle.com/javase/tutorial/collections/interfaces/index.html
// TODO: https://docs.oracle.com/javase/8/docs/api/index.html?java/util/Collection.html
public static void main(String[] args) {
Curso curso1 = new Curso("Historia",30) ;
Alumno alumno1 = new Alumno("Luis Miguel", "001");
Alumno alumno2 = new Alumno("Pepito los palotes", "002");
Alumno alumno3 = new Alumno("Juan Carlos", "003");
Alumno alumno4 = new Alumno("Pedro Pedrito", "004");
Alumno alumno5 = new Alumno("Gustavo Sanchez", "005");
Alumno alumno6 = new Alumno("Marcia Maria", "006");
Alumno alumno7 = new Alumno("Claudia Patricia", "007");
curso1.addAlumno(alumno1);
curso1.addAlumno(alumno2);
curso1.addAlumno(alumno3);
curso1.addAlumno(alumno4);
curso1.addAlumno(alumno5);
curso1.addAlumno(alumno6);
curso1.addAlumno(alumno7);
// Recorremos con un lambda
//curso1.getAlumnos().forEach(alumno -> System.out.println(alumno));
// Iterator para recorrer la lista
Iterator< Alumno> alumnoIterator = curso1.getAlumnos().iterator();
// Con el hasNext () vamos uno por uno..
while (alumnoIterator.hasNext()){
// Con el next() avanzamos
System.out.println(alumnoIterator.next());
}
// alumnoIterator.next(); error..
}
}
¿Cuál método es usado para recorrer los valores de un Iterator? Seleccione una alternativa next() ¡Alternativa correcta! El método next es usado para recorrer los valores de un Iterator. hasNext() ¡Alternativa incorrecta! El método hasNext sirve para validar si existe valores para recorrer
Clase 17 Ante la elección de set y list, usamos COllection como clase padre, luego podemos variar.. Y cambiar entre una o bien la otra. Clase 8, comparamos para saber que elegir.
package com.alura;
import com.alura.model.Alumno;
import com.alura.model.Curso;
import java.util.Iterator;
public class Clase17 {
// TODO: https://docs.oracle.com/javase/tutorial/collections/interfaces/index.html
// TODO: https://docs.oracle.com/javase/8/docs/api/index.html?java/util/Collection.html
public static void main(String[] args) {
Curso curso1 = new Curso("Historia",30) ;
Alumno alumno1 = new Alumno("Luis Miguel", "001");
Alumno alumno2 = new Alumno("Pepito los palotes", "002");
Alumno alumno3 = new Alumno("Juan Carlos", "003");
Alumno alumno4 = new Alumno("Pedro Pedrito", "004");
Alumno alumno5 = new Alumno("Gustavo Sanchez", "005");
Alumno alumno6 = new Alumno("Marcia Maria", "006");
Alumno alumno7 = new Alumno("Claudia Patricia", "007");
curso1.addAlumno(alumno1);
curso1.addAlumno(alumno2);
curso1.addAlumno(alumno3);
curso1.addAlumno(alumno4);
curso1.addAlumno(alumno5);
curso1.addAlumno(alumno6);
curso1.addAlumno(alumno7);
// Direrentes formar de recorrer..
curso1.getAlumnos().forEach(alumno -> System.out.println(alumno));
Iterator< Alumno> alumnoIterator = curso1.getAlumnos().iterator();
while (alumnoIterator.hasNext()){
System.out.println(alumnoIterator.next());
}
alumnoIterator.next();
}
}
¿Cuál método puede usar una lista para trabajar con Iterator? Seleccione una alternativa iterator() ¡Alternativa correcta! El método iterator devuelve un Iterator
En nuestra Clase17.java vamos a modificar este código: alumnoIterator.next(); Y vamos a cambiarlo por el siguiente código para evitar el exception NoSuchElementException: try { alumnoIterator.next(); } catch (NoSuchElementException e){ System.out.println("No Existe"); }
Lo que aprendimos en esta aula: Leer valores de una lista usando la interfaz Iterator a través del método next(). Saber el exception que puede dar cuando usamos el método next() de forma incorrecta. Saber que la interfaz Iterator era una forma antigua de leer los valores de una lista. Saber que la principal diferencia entre un Set y List es que el primero no guarda registros duplicados, además que saber que la forma de leer esos valores además de usar un for, es a través de la interfaz Iterator Reconocer que un Set y List forman parte de la interfaz Collection y por ello podemos usar los métodos que contiene ella.
Clase 18
El map viene de java.util, pero no es de Collection
Todo mapa posee una key, "String", y el value, "Alumno"
private Map
package com.alura;
import com.alura.model.Alumno;
import com.alura.model.Curso;
import java.util.Iterator;
import java.util.Optional;
public class Clase18 {
// TODO: https://docs.oracle.com/javase/tutorial/collections/interfaces/index.html
// TODO: https://docs.oracle.com/javase/8/docs/api/index.html?java/util/Collection.html
public static void main(String[] args) {
Curso curso1 = new Curso("Historia",30) ;
Alumno alumno1 = new Alumno("Luis Miguel", "001");
Alumno alumno2 = new Alumno("Pepito los palotes", "002");
Alumno alumno3 = new Alumno("Juan Carlos", "003");
Alumno alumno4 = new Alumno("Pedro Pedrito", "004");
Alumno alumno5 = new Alumno("Gustavo Sanchez", "005");
Alumno alumno6 = new Alumno("Marcia Maria", "006");
Alumno alumno7 = new Alumno("Claudia Patricia", "007");
curso1.addAlumno(alumno1);
curso1.addAlumno(alumno2);
curso1.addAlumno(alumno3);
curso1.addAlumno(alumno4);
curso1.addAlumno(alumno5);
curso1.addAlumno(alumno6);
curso1.addAlumno(alumno7);
//curso1.getAlumnos().forEach(alumno -> System.out.println(alumno));
// Buscamos en función del código del alumno.
// Recibimos un Optional, porque puede tener o no.
Optional< Alumno> alumno = curso1.getAlumnos().stream().filter(a -> "003".equalsIgnoreCase(a.getCodigo())).findFirst();
// Con isPresent funciona con el Optional
if(alumno.isPresent()){
System.out.println(alumno.get());
}
// Nos devuelve el alumno en sí.
Alumno alumnoMap = curso1.getAlumnoMap().get("003");
System.out.println(alumnoMap);
}
}
¿Cuál es la mejor definición para mapas? Seleccione una alternativa Un mapa es una interfaz, hace parte del package java.util no posee métodos de la interfaz Collection, trabaja bajo un concepto de (llave, valor) ¡Alternativa correcta! Todo lo detallado es parte de la definición de mapas
Clase 19
Es una manera..
private Map
package com.alura;
import com.alura.model.Alumno;
import com.alura.model.Curso;
import java.util.Optional;
public class Clase19 {
// TODO: https://docs.oracle.com/javase/tutorial/collections/interfaces/index.html
// TODO: https://docs.oracle.com/javase/8/docs/api/index.html?java/util/Collection.html
public static void main(String[] args) {
Curso curso1 = new Curso("Historia",30) ;
Alumno alumno1 = new Alumno("Luis Miguel", "001");
Alumno alumno2 = new Alumno("Pepito los palotes", "002");
Alumno alumno3 = new Alumno("Juan Carlos", "003");
Alumno alumno4 = new Alumno("Pedro Pedrito", "004");
Alumno alumno5 = new Alumno("Gustavo Sanchez", "005");
Alumno alumno6 = new Alumno("Marcia Maria", "006");
Alumno alumno7 = new Alumno("Claudia Patricia", "007");
curso1.addAlumno(alumno1);
curso1.addAlumno(alumno2);
curso1.addAlumno(alumno3);
curso1.addAlumno(alumno4);
curso1.addAlumno(alumno5);
curso1.addAlumno(alumno6);
curso1.addAlumno(alumno7);
//curso1.getAlumnos().forEach(alumno -> System.out.println(alumno));
// Más sencillo de usar.. Haciendo un get sobre el map
Alumno alumnoMap = curso1.getAlumnoMap().get("003");
curso1.getAlumnoMap().forEach((codigo, alumno) -> {
System.out.println(alumno);
});
//System.out.println(alumnoMap);
}
}
¿Por qué usar un mapa? Seleccione una alternativa Obtener valores a través de una llave única, hace más rápido la búsqueda de información ¡Alternativa correcta! Un mapa trabaja bajo un concepto de (llave, valor), al tener una llave única por ejemplo un DNI, termina siendo más rápido la búsqueda de información.
En nuestra Clase19.java vamos adicionar 3 alumnos nuevos y imprimir la nueva lista de alumnos
curso1.getAlumnoMap().put("008", new Alumno("Juan Miguel", "008") );
curso1.getAlumnoMap().put("009", new Alumno("Maria Jose", "009") );
curso1.getAlumnoMap().put("010", new Alumno("Luis Pedro", "010") );
curso1.getAlumnoMap().forEach((codigo, alumno) -> {
System.out.println(alumno);
});
Saber que un Map nos permite acceder a sus valores con más rapidez porque trabaja en el concepto de llave única y valor. Buscar valores de un mapa a través de un key termina siendo mucho más rápido que un List o Set. El usar mapas es muy útil cuando tenemos registros únicos en nuestros registros como DNI, numero de celular, etc. Porque así podemos diferenciar nuestros valores y colocarlos como llave única en nuestros registros. Leer valores de un Map.