Object Oriented Programming

La POO ó OPP en inglés. Filosofía de Orientación a Objetos—surge a partir de los problemas

que tenemos y necesitamos plasmar en código.
Analizar el problema en forma de objeto, empieces a ubicar los objetos relaciones a ese
problema—para posteriormente dale una solución. El problema empieces a orientarlo a
objetos y así darle solución.
POO—Es un paradigma de programación (teoría q suministra la base y modelo para resolver
problemas)—OO manera de resolver problema.
Y ESTOS SON LOS 4 PILARES de la POO:
1. Encapsulations
2. Abstraction
3.Inheritance
4.Polymorphism

Paradigmas de la programación:
 Programación orientada a procedimientos: Fácil de reutilizar código, si existe
fallo, código espagueti.
 Programación orientada a objetos Similar característica a la vida real,
abstrayendo estas características de estos objetos y representarlo por código.
 Trasladar la naturaleza de los objetos de la vida real. Ej: si falla una pieza, como
una llanta de un coche, puede seguir conduciendo.

Class
 Model where are defined the common features and methods of a entity.
PAQUETES Están las clases que de alguna manera tienen una relación entre ellas.

[Implicit inheritance]

Inheritance
Se pueden tener 2 clases para un mismo objeto en java?
To conclude, the inheritance mechanism in Java is limited to inheriting one class, but
multiple interfaces can be inherited (implemented) on a single class.

An interface is a reference type used to specify the properties and behaviors of a class.

You can’t create an instance of an interface. Instead, you need to implement the interface on
a class and instantiate the implementing class.
When you need to extend two classes or more, using interfaces is the only way to go in
Java.

Estatico Hay una sola copia en la memoria.

Null No reference to an object. No instance, object is assigned to the variable or field. Data
primate NEVER NULL.
Nulls
 If there isn’t a variable referencing to an object, it would be “NULL”.

* Nulls-->Isn't referencing to nothing at all. There isn't box to reference.

* Like a box. Is a object is referecing "Null", it's
* It's to control the memory.
* It's used ! or == or changing the order of the comparations.

GETTERS AND SETTERS

Control and protect access to private fields.
The utility of using getters and setters is the flexibility:
We force people to use these methods to use these methods to see if the data what they are using is valid or
not according to a criteria and just expecting what we desire. Or also just get a part of the information
according to many attributes, it’s all about control, encapsulation, consistency and flexibility.
  Another good example to control data from setters:

Constructor
 There are implicit constructors.
Constructor Chaining
You can call a constructor from another constructor.
IT HAS TO BE THE FIRST EXECUTABLE STATEMENT.

Remember: .this and .super are used to refer to the inner or extended class.

 Static Methods:
Reference vs Objects vs Instance vs Class
1. Blueprint The class
2. House  The object built with that class.
3. House’s address/Piece of paper. Reference (Tell someone where do we leave)
4. Referencing the house copying the paper where is the address, but we don’t
copy the house itself.

Ejemplo
1- Bluehose referencing to an object in memory
2- anotherHouse referecing to the same object in memory. So this new house is
gonna have the same methods, attributes, etc stored in this memory’s space.
Static variables vs Instance Variables
It’s no about NOT CHANGING, it’s about BELONGING TO A CLASS.
IT’S A BEST PRACTICE TO ACCESS THROGUHT THE CLASS NAME AND
NOT A OBJECT
It’s no necessary and object to use it.
o Used by:
 Unique id
 Controlling acces or shared resource.
Static methods vs Instances Methods
Doenst use instance variables or the use of .this
For more flebility and easy way to créate objects, e.g: Calculator.printSum(a,b)
Helper methods: Helper functions within an class. These methods can perform
tasks that are relataed to the class but don’t requiere Access to any instance-
especific data.
For using constants.
For using the main method.
Instance methods
Can Access instance methods and instance variables directly.
¿Does it use any fields (instances variables) or isntance methods?-->
TrueInstance method
False Static method if we aren’t use any fields of the class.
POJO ( Plain Old Java Object)
Only has instance fields
Used to pass data between functional classes (e.g a DTO class pass data form
the DTO Class to the Controller class.
Many database framework use POJO to read from, or to write data to,
databases.
JavaBean, Entity, DTO.
Description o fan object.
Repetitive code for just 4 fields.
The POJO vs The Record
Record
More resctrictive Protect data from manipulations
Data that wont never be altered.
Have fundamental methods, constructors or Access.

The fields are declared private and final  That’s why we can’t user SETTERS .
Also generates a public accesor method. Without .get or other preindex.
When do we use either POJO or Record?
If I wanna modify data of the objects, use POJO.
If I’m reading whole lot of records, from a database or file source,, and simply
passing this data, then the RECORD is a huge improvement.
If I wanna just hold data and don’t modify behaivor or state of a object, just
holding immutable data so no setters, I can use RECORD.
 I wanna user multiple inheritance, we use POJO, because RECORD can’t
support multiple inheritance, but we can use the sealed keyword to define
possible subtypes.
e g : Objects from a certain material and their mechanicals properties. Another
example: The 121 chemistry’s elements from the table. Those properties never
gonna change.

Polymorphism
Polimorfismo: Respuesta distinta e independiente en funcion de las diferentes
implementaciones. Un objeto con muchas formas.
o PoliMuchas
o MorfismoFormas
Abstract classes
Clases con estructura muy generales, donde las clases hijas definen los detalles.
No puede ser instanciada solo heredada. Util cuando existe una correlación
entre distintos elementos (Definir subclases)Uso del polimorfismo.
Se define que se va a hacer pero no se especifica.
Puede llevar métodos no abstractos.
En la clase podemos definir varios métodos y propiedades pero solo los que
declaremos como abstractos son los que modificaremos en las clases
heredadas.
Cuando usarla? Cuando se requiere hacer uso del polimorfismo y generar un
englobe de distintos elementos.
Como? Simplemente una clase con un metodo o propiedad no definidos.

Nota importante:
1. Cuando defines una clase abstracta, esta no puede ser instanciada.
2. Polimorfismo se refiere a que todos les da una misma orden pero se comportan o
reaccionan de manera diferente.

Interfaces
Desacoplar el código y mejorar mantenimiento de este.
Se recomienda definir una clase JAVA en cada fichero .java
Se pueden implementar varias interfaces separadas por una “,”
El típico ejemplo que realizas en crear una capa de servicios y otra capa de
implementación de esos servicios. Porque entonces allí no usastes una clase
abstracta? Rpta:// Porque no había una correlación directa entre la clase y
subclases, era simplemente definir unos metodos y luego implementarlos, sin
relación directa.
RECUERDACADA METODO SOLO HACE 1 TAREA.

Un contrato, una serie de acciones a implementar.

Para ver los objetos construidos, hay q generar un método toString.
Muy ineficiente (cada vez que llenaba la lista, creaba otra ya que se me volvía
insostenible o cambiamos la tecnología).
Eficiente(Bajo acoplamiento): Proporcionan una manera comun de hacer algo. Cada clase
implementa los metodos que
estan descritos a su manera.

Encapsulation
 Encapsulamiento. Quiere decir que oculta datos mediante código.

 Desde la Clase 4 no puedo rebobinar, poner una canción, etc. ¿Por qué? Y a q
solo desde cierta clase se puede hacer cierta tarea, como poner una canción, ya
que hay cosas que se pueden hacer solo en una sola clase.
 Las propiedades de una clase solo se puedan modificar desde la misma clase,
no desde otra clase.
  Hide attributes, methods, from other classes.

Abstraction
 Abstracción. Es como se pueden representar los objetos en modo de código.
• Abstracción: Práctica de aislar un elemento de su contexto, o el resto de los elementos
que lo acompañan consiguiendo de ese modo, reducir ese elemento a sus características mas
esenciales.

Data type

Recuerda que en JAVA existen 2 tipos de datos: primitivos y tipo objetoNo se pueden
comparar con el operador “==” los de tipo objeto (tipos primitivos envueltos en una clase, lo
que los convierte en objetos) y Estructurados (clases nuestras, terceros, vectores).
Nota Es por eso que sale el metodo de la clase Object: .equals(Object o) ya
que aquí se determina son son esos objetos iguales.
Classes
Class Object

Clase raíz de donde provienen todas las clases de JAVA

PUEDES TENER TANTOS CONSTRUCTORES COMO QUIERAS.

• Puedes jugar con los constructores de objetos como quieras. Piensa que son
constructores, hacen, definen, organizan lo que quieran.
Overloading:
duplicar métodos con distintos argumentos

 La siguiente imagen explica porque al momento de tu crear el metodo de toString(),

hashCode() o equals(Object o) aparece la anotación @override (que significa
sobreescritura) ya que toda clase en JAVA es una subclase de la clase raíz Object.
Overriding
 Overriding: Los métodos heredados se pueden MODIFICAR en la clase hija.

 Super  Its posible to call methods of higher jerarqy.

Methods
Nota Existe una diferencia entre Metodos de clase y Metodos de instancia.
StaticMetodo o atributos que pertenecen a la clase, lo q permite acceder a atributos o
métodos sin necesidad de la creación de un objeto. ÚtilConstantes(Pi,IVA,etc).
Super
Recuerda que para llamar al constructor ó metodo de la clase padre en la clase
hija se usa el metodo super(atributo/metodo de clase padre).

Nested classes
Util cuando usas clases que solo se usan en un lugar. Crea codigo mas
mantenible y fácil de leer (la razón? En vez de estar teniendo un montón de
clases que solo usarás una sola vez, pues mejor haces eso).
2 tipos de clases anidadas  (Dentro de una clase hay otra clase y esta clase
tiene sus metodos, propiedades, etc.)
o Static nested class: Solo puede acceder a metodos o propiedades
estaticas definidos en su clase adjunta. Está precedido por la palabra
static.
o Inner class: Tiene acceso a metodos y campos de la clase exterior
 Local inner class: Se definen dentro de un bloque, ejemplo: for, if,
etc. No son miembros de clase adjunta y se debe crear una instancia
dentro del mismo bloque para ser llamada.
 Anonymus inner class: Clases anidads sin un nombre de clase. Se
declaran como una subclase dentro de una clase existente o como la
implementación de una interfaz.
Tienen acceso a las propiedades y metodos de la clase exterior pero no al reves.

Conditionals
(expresion)?siEsVerdadero:siEsFalso.
Concurrency in JAVA
Concurrencia es la capcidad de ejecutar multiples hilos independientes de
manera simultanea. Es el concepto mas general de realizar varias cosas al
mismo tiempo.
Tener varias tareas ejecutándose no necesariamente al mismo tiempo.
Ej: ciudades muy grandes, que solo tienen un carril. Habría muchos coches
detrás esperando… Le empezamos a añadir carriles, coches tienen mayor
libertad para elegir, varios coches realizan varias operaciones a la vez y no
habría congestion.
o Similar a la vida real, que unos proceso sgeneran bloqueos entonces
necesitan que ejecutar otros hilos de manera simultanea
o DEPENDE del numero de nucleos, a mayor numero de nucles, mayor
numero de hilso.
Thread o Runnable:
Prefereible implentar la interfaz Runneable: JAVA no permite la herencia
multiple, y si ya hemos herado de la clase Thread, ya no podremos otra
vez volver a heredar, en cambio, podemos implementar multiples
interfaces, usamos mejor Runnable.

Los programas actuales son multitareas.

Para hacer una pausa durante la ejecución de un programa usamos el metodo
Sleep(longMilisegundos de pausa). Sleep(4000)  4 segundos.
o Lanza una exception InterruptedException  Estamos obligados a
capturar con un bloque try catch . Le indicamos a ese hilo de ejecución
que espere 4 segundos. El segundo hilo no puede terminar hasta que el
primer hilo termne.
Se encuentra ejecutan un hilo, constantemente ejecutando ese buble for.
En la imagen de arriba ya varios hilos puedene empezar en sus hilos.
si yo pulso otra vez "Dale", solo aparece una bola solo permite un hilo de
ejecución. La 2da saldrá cuando esa termine de ejecutarse.
A thread es un hilo de ejecución en un programa. La JVM permite una app tenga
multiples hilos de ejecución de manera concurrente.
Runnable runnable=new PelotaHilos(pelota,lamina); Runable
interface deberpia de implementarse por cualquier instancia que
quieren ser ejecutadas por un hilo.

En la siguiente imagen se observa que se ejecutan multiples programas de

manera simultanea (Pero no necesariamente al mismo tiempo). Lo que pasa es
que como ocurre tan veloz, da la sensación de que se ejecutan al mismo tiempo.

LA CPU le asigna un tiempo a cada tarea, tiene t segundos para ejecutarse.

Puede que hagan mucho o poco durante ese t tiempo. Y así se van rotando… y
se hace tan rapido que nos parece que fuera al mismo tiempo.
Solo tengo 2 nucleos, pero necesito ejecutar 4 hilos, y que se ejecuten rapido. Al
OS le digo, lanzame 4 hilos, pero yo en mi CPU de 4 nucleos quiero q se
ejecute. El OS con la CPU dice: “a cada tarea le da un t tiempo, y le dice al
nucleo 2 le asigna una tarea, y asi se van intercambiando para q se vayan
ejecutando lo más rapido posible.
Pasos para convertir a multitarea.

When an object implementing interface {@code Runnable} is used

* to create a thread, starting the thread causes the object's
* {@code run} method to be called in that separately executing
* thread.
* Ahora ya sí se puede Crear las tareas multihilos:

Metodos de interrupción de 1 threads

Interrup()  Solicitar la interrupción de un hilo.

isInterrupted()  True or False si un hilo se encuentra o no interrupido.
interrupted() Lo mismo que el anterior.
SleepBloquemos el hilo(No se puede hacer nada).  InterrupimosException
Metodos de interrupción de varios threads
General Methods
.notify()  Es un método que se utiliza en el contexto de la programación
multihilo para controlar la sincronización y la comunicación entre hilos. Este
método se llama en un objeto y notifica a otro hilo que está esperando en ese
objeto que puede continuar su ejecución

.syncronized()  SINCRONIZAR BLOQUES DE CODIGO, ES DECIR, SOLO 1 HILO PUEDE

ACCEDER AL CODIGO, SE USA PARA EVITAR. EVITAR Q 2 HILOS ACCEDAN AL MISMO
CLIENTE. MIENTRAS 1 ACCEDE, EJECUTA EL CODIGO QUE ESTE EN EL SYNCRONIZED, Y
LOS OTROS ESPERAN HASTA QUE ESTE ALLÁ EJECUTA EL CODIGO.
synchronized(lock) {
colaClientes.offer(cliente); //offer(doesn't throw an
exception when is full) != add (it does)
lock.notify();}}

.wait()  Es un método de la clase java.lang.Object que se utiliza en

programación multihilo para suspender la ejecución de un hilo hasta que se
cumpla una cierta condición.

NOTA IMPORTANTE: los metodos object de las concurrencias siempre van

dentro de un syncronized.
Exercise of race (Using threads)

Ejercicio de Countdown
El comportamiento que estás observando en tu código, donde funciona correctamente cuando
agregas Thread.sleep(5000) en el hilo principal, es debido a que esta pausa permite que el hilo principal
dé tiempo a los hilos secundarios para realizar su trabajo antes de que se detenga el programa. Sin
embargo, esta solución no es la más adecuada en términos de diseño y sincronización de hilos.

La razón principal por la que el código no funciona como se esperaba sin Thread.sleep(5000) es que los
hilos userTaskThread y countdownThread pueden no tener tiempo suficiente para ejecutar sus tareas
antes de que el hilo principal salga del

bucle while(true) y detenga la

ejecución del programa.

El problema en tu código es que los hilos secundarios ( userTaskThread y countdownThread) a veces no

tienen suficiente tiempo para ejecutarse antes de que el hilo principal termine el programa. Por eso,
agregar Thread.sleep(5000) en el hilo principal da tiempo a los hilos secundarios para completar su
trabajo.
¿Cuando realmente usamos el Runnable vs el Threads?

Parallelism in JAVA
Todo el paralelismo es concurrencia pero no toda la concurrencia es paralelismo.
Se necesitan varios nucleos.
Thread Una unidad de ejecución independiente. Imagina esto como 2 hilos.
Para que sea paralelismo los procesos tiene que formar parte de una tarea. Ej:
SO->Abrir nagevador web y Bloc de notas, todo al mismo tiempo: Esto es
concurrencia puesto que son 2 procesos independientes que se ejecutan al
mismo tiempo y NO PARALELISMO porque no tienen nada q ver.
o Ej: trabajo para clase Si lo hago yo, me demoraré mucho, pero si lo
hacemos entre varias personas esa misma tarea, me demoraré mucho
menos.

Concurrency vs Parallelism
parallelism is a condition that arises when at least two threads
are executing simultaneously where as concurrency is a condition that exists
when at least two threads are making progress. Concurrency is a more
generalised form of parallelism that can include time-slicing as a form of
virtual parallelism.
Going by simpler words, when you divide an enormously sized computational task
into smaller subtasks, and run them in parallel in modern day multicore
CPU/GPU, parallelism occurs. On the other hand, concurrency happens when
two tasks (not necessarily interdependent) start, run and complete in overlapping
time periods. This does not mean that they run at exactly the same instant, i.e.,
concurrency can happen on a single processor system with effective time sharing.
Importantly, a different task begins before the ongoing task completes.

Concurrency and parallelism are related terms but not the same, and often misconceived as the
similar terms. The crucial difference between concurrency and parallelism is that concurrency is
about dealing with a lot of things at same time (gives the illusion of simultaneity) or handling
concurrent events essentially hiding latency. On the contrary, parallelism is about doing a lot of
things at the same time for increasing the speed.

Parallelly executing processes must be concurrent unless they are operated at the same instant but
concurrently executing processes could never be parallel because these are not processed at the
same instant.

En concurrencia trabajas en tareas que son ejecutadas al mismo tiempo y de

forma independiente. En paralelismo, divides el trabajo en sub-tareas para que
pueda ser finalizado por más ejecutores.
 Paralelismo implica realizar varias tareas verdaderamente al mismo tiempo,
aprovechando recursos físicos múltiples, como núcleos de CPU o quemadores
en una estufa.
Concurrencia implica administrar múltiples tareas de manera eficiente, dividiendo
el tiempo y los recursos de manera que parezca que se están ejecutando al
mismo tiempo, aunque puedan ejecutarse de manera intercalada.

Loops
Util classes

Arrays
 Array: An array is an
index-based data structure, which means every element is referred by an index. An array
holds same data type elements.

Cuando creas un array en JAVA, se inicializan o “llenan” todos los elementos.

1. Int [][] numbers={{1,2,3},{4,5,6},{7,8,9}}
2. Int [][] numbers=new int [4][6]

String class
String()
 String(String s)
String( char[ ] v)
String (char[ ] v, int pos, int n)
.compareTo/ .compareToIgnoreCase(String)
.valueOf(N)
.concat(String v)
Math

Collectors
La clase Collectors no solo tiene métodos para convertir en List, sino también en String
(uniéndolos), y muchos casos como a continuación se muestra:
1. // Accumulate names into a List
2. List<String> list = people.stream()
3. .map(Person::getName)
4. .collect(Collectors.toList());
5.
6. // Accumulate names into a TreeSet
7. Set<String> set = people.stream()
8. .map(Person::getName)
9. .collect(Collectors.toCollection(TreeSet::new));
10.
11. // Convert elements to strings and concatenate them, separated by commas
12. String joined = things.stream()
13. .map(Object::toString)
14. .collect(Collectors.joining(", "));
15.
16. // Compute sum of salaries of employee
17. int total = employees.stream()
18. .collect(Collectors.summingInt(Employee::getSalary));
19.
20. // Group employees by department
21. Map<Department, List<Employee>> byDept = employees.stream()
22. .collect(Collectors.groupingBy(Employee::getDepartment));
23.
24. // Compute sum of salaries by department
25. Map<Department, Integer> totalByDept = employees.stream()
26. .collect(Collectors.groupingBy(Employee::getDepartment,
27. Collectors.summingInt(Employee::getSalary)));
28.
29. // Partition students into passing and failing
30. Map<Boolean, List<Student>> passingFailing = students.stream()
31. .collect(Collectors.partitioningBy(s -> s.getGrade() >= PASS_THRESHOLD));
32.

Records
Recordsimilar a DTO.
o Transportar información de un modulo a otro dentro del programa.
https://www.youtube.com/watch?v=okebyMU1ta8&ab_channel=makigas
%3Aaprendeaprogramar

En Java, una "class" es una plantilla que define la estructura de un objeto, es decir, cómo se debe
crear un objeto, qué propiedades tiene y qué comportamientos puede tener. Por otro lado, un
"record" es una nueva característica introducida en Java 14 que es una versión simplificada de una
"class" diseñada para representar datos inmutables, es decir, objetos cuyos valores no cambian
después de ser creados y que se utilizan principalmente para modelar datos de forma más concisa y
legible.

Ahora bien, las diferencias clave entre un "record" y una "class" son las siguientes:

1. Sintaxis simplificada: Los "records" en Java tienen una sintaxis más breve y concisa en
comparación con las "class". Por ejemplo, en un "record" solo necesitas declarar los nombres
de los campos y sus tipos de datos en la definición, mientras que en una "class" necesitas
declarar los campos, definir sus getters y setters, hashCode(), equals() y toString() de manera
explícita.
2. Inmutabilidad: Los "records" son automáticamente inmutables, lo que significa que una vez
que se crean, no se pueden modificar. En cambio, las "class" son mutables por defecto, lo que
permite cambiar sus valores en cualquier momento.
3. Herencia limitada: Los "records" no pueden extender otras "class" pero sí pueden implementar
interfaces. Por otro lado, las "class" en Java pueden extender otras "class" y/o implementar
interfaces.
4. Propósito: Los "records" están diseñados principalmente para representar datos inmutables y
simplificar la creación de clases de datos, mientras que las "class" en Java se utilizan para
modelar objetos con comportamientos y estados más complejos.

Ahora, para darte una analogía sencilla, puedes pensar en una "class" como un molde de galletas que
tiene varias formas y detalles, y un "record" como un molde de galletas más pequeño y simple que
solo tiene una forma básica. Ambos pueden crear galletas, pero el molde más simple y pequeño del
"record" está diseñado específicamente para hacer galletas con una forma y sabor específicos de
manera rápida y eficiente, mientras que el molde más completo y detallado de la "class" puede crear
galletas con diferentes formas y sabores, y también puede cambiar su forma o sabor después de ser
creadas.

RECORD:
1. public record Person(String firstName, String lastName, int age) {
2. // Records automatically generate constructor, accessor methods, equals, hashCode, and toString.
3. }
4.

CLASS:
1. public class Person {
2. private String firstName;
3. private String lastName;
4. private int age;
5.
6. public Person(String firstName, String lastName, int age) {
7. this.firstName = firstName;
8. this.lastName = lastName;
9. this.age = age;
10. }
11.
12. public String getFirstName() {
13. return firstName;
14. }
15.
16. public void setFirstName(String firstName) {
17. this.firstName = firstName;
18. }
19.
20. public String getLastName() {
21. return lastName;
22. }
23.
24. public void setLastName(String lastName) {
25. this.lastName = lastName;
26. }
27.
28. public int getAge() {
29. return age;
30. }
31.
32. public void setAge(int age) {
33. this.age = age;
34. }
35.
36. @Override
37. public boolean equals(Object obj) {
38. if (this == obj) return true;
39. if (obj == null || getClass() != obj.getClass()) return false;
40. Person person = (Person) obj;
41. return age == person.age &&
42. Objects.equals(firstName, person.firstName) &&
43. Objects.equals(lastName, person.lastName);
44. }
45.
46. @Override
47. public int hashCode() {
48. return Objects.hash(firstName, lastName, age);
49. }
50.
51. @Override
52. public String toString() {
53. return "Person{" +
54. "firstName='" + firstName + '\'' +
55. ", lastName='" + lastName + '\'' +
56. ", age=" + age +
57. '}';
58. }
59. }
60.

Exceptions and handling errors

Todo error es un objeto de alguna clase de tipo Throwable.
Manejo de excepciones es similar a manejo de errores.
o Excepciones
 IOException Propio del sistema
 Runtime Exception  Del programador.

Throw y throws
Lanzar nuestras propias excepciones.
Throws Declarar q ese método va a lanzar una excepción.
throw Lanzamos el objeto creado, en este caso una excepción que no es más que una clase
que hereda de la clase Exception:

Nota: Centralizar las excepciones: no hacer un try -catch para cada excepción que se presente,
en el siguiente caso se digitaría hacerReporte().
NotaTambien podes crear excepciones propias.
1. Error en tiempo de ejecuciónError que no estábamos preparados que hace que nuestro programe aborte
2. Error de compilaciónFalta un ;, o algo mal escrito, error típicamente sintaxico.
3. Error chumMenos visible de todos, error lógico o humano: lo q yo le he dicho al programa esta mal dicho,
mi posible lógica esta mal.
ThrowsDeclarar que función que puede ser que se generará esa excepción. Esto en caso de que el método
no maneja una excepción marcada.
Throwgenerar una excepción . Invocar explícitamente una excepción.

Streams & Lambda

Important Notes

 IMPORTANTE: int sum=numbers.stream().mapToInt(n->n).sum();

//Porque la suma se hace. SI QUEREMOS USAR LOS DISTINTOS METODOS,
TENEMOS QUE CONVERTIR A IntStream, o DoubleStream.

 Solo para mayor claridad: Cuando tengo un array como int [ ], y se quiere obtener un stream
de ese array para bien sea convertirlo a lista o lo que sea, se puede usar el
Arrays.stream(nums).boxed().collect(Collectors.toList());

 To find the sum of all numbers of a Collection in JAVA, we can use the following
method:

int sum2=numbers.stream().reduce(0, (a,b)->a+b);1.

 Nota importante Recuerda que para convertir en lo que queramos

(List, Map, Set, Queue or Stack) hay que usar el metodo:
.collect(Collectors.toList());

 En el siguiente método se sacá el valor máx, estamos usando la programación

funcional y el método ‘reduce’ con la función de reducción ‘Integer::max’. Los ‘::’
en ‘Integer:max’ son la sintaxis de referencia a método en Java, que permite
referenciar a métodos existentes en lugar de definir funciones lambda. En este
caso, ‘Integer::max’ se refiere al método ‘max’ de la clase ‘Integer’ que se usa
para encontrar el máximo entre 2 valores enteros.
1. int maxWithReference=numbers.stream().reduce(Integer::max).get();
2. int max=numbers.stream().reduce(0, (a,b)->a>b?a:b);

 Se presenta de más el siguiente ejemplo:

1. .map((employee)->{return employee.getSalary();}) == .map(Employee::getSalary)

 El metodo .mapToInt(n->n) de la clase Stream, lo que hace es convertir todos

esos elementos que va pasando la secuencia de numeros en objetos de tipo
Integer, en donde allí si se puede usar ciertas funciones existentes para dicha
 clase. Es decir, que si queremos usar esos metodos que vienen por defecto,
tendríamos que pasar de un stream a un IntStream o DoubleStream.

1. OptionalDouble avg=numbers.stream().mapToInt(n->n).average();
2. distinct()(Saca valores unicos de un stream.

Reduce
Sum, min, max, average, and string concatenation are all special cases of reduction. Summing a
stream of numbers can be expressed as:
 Integer sum = integers.reduce(0, (a, b) -> a+b);
or:
 Integer sum = integers.reduce(0, Integer::sum);

Map

FlatMap
Filter
Range & rangeClosed

Iterate

Generate

Lambda Functions
Funciones anónimas que no necesitan de una clase.
Tipo de porgramacion decalrativa y no imperativa.
LE ESTASMO DANDO ORDENES al programo,Imperativo
JAVA no es un lenguaje funcional, es un lenguaje POO, pero que ha heredado el
lenguaje funcional.
1. public static String toMayusclua(String nombre) {
2. return nombre.toUpperCase();
3. }
4. private Function<String,String> toMayus = x -> x.toUpperCase();

- Esas dos funciones anteriores son exactamente las mismas!

Las expresiones lambda son un método sin declaración, es decir, sin

modificadores de acceso, que devuelve un valor y un nombre. Permiten escribir
un método y utilizarlo inmediatamente.
o Esto es útil en el caso de una única llamada a un método, ya que permite
reducir el tiempo de declarar y escribir el método sin tener que crear una
clase.
Sintaxis:

¿Necesidad?
- Aportan funcionalidad al lenguaje otorgando igualdad de condiciones a todos
los objetos. En java, las expresiones lambda se encuentran representadas por
objetos, y necesitan ser asociadas a un tipo de objeto particular llamado
interfaz funcional.
Estructura de las expresiones Lambda en Java

Una estructura de expresiones lambda se caracteriza por:

 Tener cero o varios parámetros de entrada.
 El tipo de parámetro se puede especificar explícitamente o puede derivarse del contexto. Por ejemplo
(int a) puede escribirse como (a)
 Los parámetros se escriben entre paréntesis y separados por comas, como puede observarse en los
siguientes ejemplos (a, b) o (int a, int b) o (String a, int b, float c)
 Si no hay parámetros, se deben utilizar paréntesis vacíos. Por ejemplo () -> 42
 Cuando hay un único parámetro, si el tipo no se especifica explícitamente, se pueden omitir los
corchetes. Ejemplo: a -> return a*a
 El cuerpo de una expresión Lambda puede contener cero o varias expresiones. Si el cuerpo de la
expresión es de una única sentencia, puede dejarse fuera de las llaves y el valor de retorno puede
especificarse sin la palabra clave return.
 Por el contrario, las llaves son obligatorias (bloque de código) y el valor de retorno debe
especificarse al final utilizando la palabra clave return (de lo contrario el tipo de valor de retorno sería
void).

Mas sobre expresiones lambdas

Collections
Enlace: https://dzone.com/articles/review-
these-java-collection-interview-quesitons-b

Summary of the major non-concurrent, non-synchronized collections

Collection: An interface representing an unordered "bag" of items, called "elements". The "next" element is
undefined (random).

 Set: An interface representing a Collection with no duplicates.

 HashSet: A Set backed by a Hashtable. Fastest and smallest memory usage, when ordering is
unimportant.
 LinkedHashSet: A HashSet with the addition of a linked list to associate elements in insertion
order. The "next" element is the next-most-recently inserted element.
 TreeSet: A Set where elements are ordered by a Comparator (typically natural ordering). Slowest
and largest memory usage, but necessary for comparator-based ordering.
 EnumSet: An extremely fast and efficient Set customized for a single enum type.
 List: An interface representing a Collection whose elements are ordered and each have a numeric index
representing its position, where zero is the first element, and (length - 1) is the last.
 ArrayList: A List backed by an array, where the array has a length (called "capacity") that is at
least as large as the number of elements (the list's "size"). When size exceeds capacity (when
the (capacity + 1)-th element is added), the array is recreated with a new capacity of (new length *
1.5)--this recreation is fast, since it uses System.arrayCopy(). Deleting and inserting/adding
elements requires all neighboring elements (to the right) be shifted into or out of that space.
Accessing any element is fast, as it only requires the calculation (element-zero-address + desired-
index * element-size) to find it's location. In most situations, an ArrayList is preferred over
a LinkedList.
 LinkedList: A List backed by a set of objects, each linked to its "previous" and "next" neighbors.
A LinkedList is also a Queue and Deque. Accessing elements is done starting at the first or last
element, and traversing until the desired index is reached. Insertion and deletion, once the
desired index is reached via traversal is a trivial matter of re-mapping only the immediate-
neighbor links to point to the new element or bypass the now-deleted element.
 Map: An interface representing an Collection where each element has an identifying "key"--each element
is a key-value pair.
 HashMap: A Map where keys are unordered, and backed by a Hashtable.
 LinkedhashMap: Keys are ordered by insertion order.
  TreeMap: A Map where keys are ordered by a Comparator (typically natural ordering).
 Queue: An interface that represents a Collection where elements are, typically, added to one end, and
removed from the other (FIFO: first-in, first-out).
 Stack: An interface that represents a Collection where elements are, typically, both added (pushed) and
removed (popped) from the same end (LIFO: last-in, first-out).
 Deque: Short for "double ended queue", usually pronounced "deck". A linked list that is typically only
added to and read from either end (not the middle).

Java Collections  Library built-in in JDK. Not needed to implement your own data structures
classes or methods. (Trees and graphs aren’t there).
 Most used data structures are: ArrayList & HashMap.

Basic collection diagrams:

Methods of Collection interface
No. Method Description

1 public boolean add(E e) It is used to insert an element in this collection.

2 Public boolean addAll(Collection<? It is used to insert the specified collection

Extends E> c) elemtns in the invoking collection.

3 Public boolean remove(Object element) It is used to delete an element from the

 collection

4 Public boolean removeAll(Collection<?> It is used to delete all the elements of the

c) specified collection from the invoking
collection

5 Public boolean removeIf(Predicate<? It is used to delete all the elements of the

Super E> filter) collection that satisfy the specified predicate.

6 Public boolean retainAll(Collection<?> c) It is used to delete all the elements of invoking

collection except the specified collection.

7 Public int size() It returns the total number of elements in the

collection

8 Public void clear() It removes the total number of elements from

the collection

9 Public boolean contains(Object element) It is used to search an element

10 Public boolean containsAll(Collection<?> It is used to search the specified collection in

c) the collection

11 Public Iterator iterator() It returns an iterator

12 Public Object[] toArray() It converts collection into array

13 Public <T> T[] toArray(T[] a) It converts collection into array. Here, the
runtime type of the returned array is that of
the specified array.

14 Public boolean isEmpty() It checks if collection is empty

15 Default Stream<E> parallelStream() It returns a possibly parallel Stream with

collection as its source.

16 Default Stream<E> stream() It returns a sequential Stream with the

collection as its source.

17 Default Spliterator<E> spliterator() It generates a Spliterator over the specified

elements in the collection.

18 Public boolean equals(Object element) It matches two collections

19 Public int hashCode() It returns the hash code number of the

collection
Notas importantes:
 Collection<?> c : Significa que es una colección de tipo genérico o desconocido. En JAVA se
usa ‘?’ para declarar tipos genéricos. Esto con el fin de que cualquier clase o implementación
de tipo pueda usar dicho método (en este caso removeAll(Collection<?> c)
 Collection<? extends E> c :
 addAll(Collection<? Extends E> c) : Indica que ‘c’ es una colección que contiene elementos de
un tipo que es una subclase o el mismo tipo que ‘E’.
 Predicate<? super E> filter : Significa que ‘filter’ es un predicado que toma un tipo que es un
supertipo de ‘E’ como argumento. Eso significa que ‘filter’ puede ser un predicado que opera
en elementos de tipo ‘E’ como sus supertipos.
 En el campo13, toArray(T[] a), es para convertir una colección en un array, pero acá se
puede especificar el tipo de array resultante.
 Stream<E> : Representa un flujo de tipo sencuencial de tipo ‘E’.
 En el elemento 15 “Default Stream<E> parallelStream()” devuelve un flujo (stream) paralelo
de elementos de la colección. Un flujo paralelo (parallel stream) es una secuencia de
elementos que se procesan de forma paralela, lo que significa que el trabajo se divide
automáticamente en múltiples hilos de ejecución para aprovechar el paralelimo y mejorar el
rendimiento en sistemas con múltiples núcleos o procesadores. Se pueden realizar
operaciones como filter, map, order, reduce de manera paralela en múltiples hilos de
ejecución (ya que cada hilo puede ejecutarse en un núleo o procesador diferente)

Map
Interfaz que representa la estructura de datos conocida como “Hash tables”. Está conformada
por:
Keys Set (Ya que no puede haber valores duplicados).
ValuesCollection (Si pueden existir).
Keys,Values  Set
HashMap
HashMap: No tiene un orden de insercción adecuado.

LinkedHashMap
LinkedHashMap: Orden de insercción de almacena mediante una estructura de
datos conocida como lista doblemente enlazada.  Muy lenta para busquedas,
porque?-->Porque para buscar un dato en una lista enlazada se tendrá q
recorrer primero todos los demás valores.
TreeMap
TreeMap: Implementacion de mapa mediante la estructura de datos árbol
binario. Se ordenan sus elementos en forma natural o no mediante un
CompareTo() o comparator().
HashMap

HashMap: A HashMap is a collection class implements Map interface. It requires a hash function
and uses hashCode() and equals() methods, in order to put and retrieve elements to and from
the collection respectively

TreeMap
TreeMap:TreeMap implements SortedMap interface. It is sorted in the ascending order of its
keys. The complexity of the operations is O(logn).

LinkedHashMap
LinkedHashMap: LinkedHashMap keeps the inserting order. The complexity is the same as
HashMap O(1). Here we can see the null, head and tail.
Enum
Enum vs HashMap
Ambas implementans la interfaz Map
Las principales diferencias entre HashMap y Enum en términos de rendimiento, velocidad, etc. son las
siguientes:

 Rendimiento: EnumMap es más rápido que HashMap en operaciones de búsqueda, inserción y

eliminación. Esto se debe a que EnumMap está optimizado para claves de enum, mientras que
HashMap puede usar cualquier tipo de objeto como clave.
 Tamaño: EnumMap es más pequeño que HashMap, ya que no necesita almacenar una tabla
hash completa. Se almacena con un array.
 Flexibilidad: HashMap es más flexible que EnumMap, ya que puede usar cualquier tipo de
objeto como clave.
 Seguridad de tipos: EnumMap es más seguro que HashMap en términos de seguridad de tipos,
ya que las claves de enum siempre se verifican en tiempo de compilación.

En general, EnumMap es una buena opción para aplicaciones que requieren un alto rendimiento y
seguridad de tipos. HashMap es una buena opción para aplicaciones que requieren flexibilidad y
compatibilidad con una amplia gama de tipos de objetos.

A continuación, se muestran algunos ejemplos específicos de cómo estas diferencias se pueden

traducir en un rendimiento mejorado:

 Búsqueda: Si necesita buscar una clave específica en un mapa, EnumMap será más rápido que
HashMap. Esto se debe a que EnumMap puede utilizar una búsqueda binaria para localizar la
clave, mientras que HashMap debe utilizar una búsqueda hash.
 Inserción: Si necesita insertar una clave nueva en un mapa, EnumMap también será más rápido
que HashMap. Esto se debe a que EnumMap no necesita reajustar la tabla hash, mientras que
HashMap puede necesitar hacerlo si la nueva clave no encaja en el hash actual.
  Eliminación: Si necesita eliminar una clave existente de un mapa, EnumMap también será más
rápido que HashMap. Esto se debe a que EnumMap no necesita recorrer la tabla hash para
encontrar la clave, mientras que HashMap puede necesitar hacerlo.

Nota RESUMEN: EnumMap se representan internamente como arrays, pero no es un array de objetos
sino arrays de enteros que representan los indices de las claves en el tipo enumerado y no tener que
calcular el hash de cada clave y al estar las claves de enum ordenadas automaticamente, permite
realizar busqueda binaria de forma eficiente.

Por supuesto, la diferencia de rendimiento entre EnumMap y HashMap variará en función de la

aplicación específica. Sin embargo, en general, EnumMap es una buena opción para aplicaciones que
requieren un alto rendimiento en operaciones de búsqueda, inserción y eliminación.

Conjunto de constantes(keys) con sus nombres descriptivos(values).

El uso de HashMap y Enum en Java depende del contexto y los requisitos específicos de tu aplicación.
Ambas son herramientas útiles, pero tienen diferencias en términos de implementación, rendimiento
y casos de uso. Aquí hay algunas similitudes y diferencias, así como algunos casos de uso comunes
para ambos:

Similitudes:

1. Representan conjuntos de valores: Tanto HashMap como Enum se utilizan para representar
conjuntos de valores en Java. Mientras que Enum representa un conjunto fijo de constantes
con nombres descriptivos, HashMap es una estructura de datos que permite almacenar pares
clave-valor, lo que puede utilizarse para representar un conjunto de valores con claves
personalizadas.
2. Permiten asignar valores a claves: Tanto HashMap como Enum permiten asignar valores a
claves. En el caso de Enum, los valores están predefinidos y son constantes, mientras que en
HashMap los valores pueden ser cualquier objeto y las claves son personalizadas.
Diferencias:

1. Implementación: Enum es una construcción del lenguaje Java y se implementa como una clase
especial en tiempo de compilación. Por otro lado, HashMap es una estructura de datos
proporcionada por Java Collections Framework y se implementa como una tabla hash en
tiempo de ejecución.
2. Rendimiento: En términos de rendimiento, Enum es generalmente más eficiente y rápido en
tiempo de ejecución, ya que las constantes Enum se resuelven en tiempo de compilación y se
almacenan en memoria como objetos en tiempo de ejecución. Por otro lado, HashMap puede
tener un rendimiento ligeramente más lento debido a la necesidad de cálculos de hash y
resolución en tiempo de ejecución.
3. Tipos de claves y valores: Enum tiene restricciones en los tipos de claves y valores, ya que las
constantes Enum están predefinidas y tienen un tipo fijo. En cambio, HashMap permite
cualquier tipo de objeto como clave y valor, lo que brinda más flexibilidad en términos de tipos
de datos utilizados.

Usos comunes:

1. Enum: Enum es adecuado cuando se necesita representar un conjunto fijo de constantes con
nombres descriptivos en un contexto específico, como días de la semana, meses del año,
opciones de configuración, etc. Enum es útil para mejorar la legibilidad y seguridad de tipos en
el código.
2. HashMap: HashMap es útil cuando se necesita una estructura de datos que permita almacenar
pares clave-valor con claves personalizadas y se necesite acceso rápido a los valores utilizando
las claves. HashMap es útil en situaciones donde los datos son dinámicos y pueden cambiar en
tiempo de ejecución, o cuando se necesita una estructura de datos más flexible y extensible.

En resumen, la elección entre HashMap y Enum en Java depende de los requisitos específicos de tu
aplicación y del contexto en el que se utilicen. Enum es más adecuado cuando se necesita un
conjunto fijo de constantes con nombres descriptivos, mientras que HashMap es más apropiado
cuando se necesita una estructura de datos flexible para almacenar pares clave-valor con claves
personalizadas y acceso rápido a los valores. Ambas son herramientas útiles y eficientes en sus casos
de uso apropiados.

[Pagina 2]
1) As said earlier, the first and foremost difference between EnumMap and HashMap is that EnumMap
is optimized for enum keys while HashMap is a general-purpose Map implementation similar to Hashtable.
you can not use any type other than Enum as a key in EnumMap but you can use both Enum and any other
Object as a key in HashMap.
2) Another difference between EnumMap and HashMap is performance. as discussed in the previous point,
due to specialized optimization done for Enum keys, EnumMap is likely to perform better
than HashMap when using an enum as a key object.
3) One more thing which can be considered as the difference between HashMap and EnumMap is
the probability of Collision. Since Enum is internally maintained as an array and they are stored in their
natural order using ordinal(), as shown in the following code which is taken from the put() method of
EnumMap
These were some notable differences between EnumMap and HashMap in Java. In short, EnumMap is best
suited for enum keys, for which it has optimized and performed better than HashMap in Java. Use EnumMap
whenever you can use enum as keys.

[Pagina 3]

Enum vs HashMaps for storing constants

Both are typically used to store constants which will be used

elsewhere in code.

But, there is a big difference in the capabilities that both offer. If

we are looking for a simple key-value kind of storage the
difference is not evident, but, for more complex use cases enum
gives much more flexibility, extensibility, readability and
maintainability than hash maps.

Case 1 (Simple): 7 days of the week

You want a data structure to store information like this
1: "Monday"
2: "Tuesday"
3: "Wednesday"
4: "Thursday"
5: "Friday"
6: "Saturday"
7: "Sunday"

Enum →
public enum DaysOfWeek {

MONDAY(1,"Monday"),
TUESDAY(2,"Tuesday"),
WEDNESDAY(3,"Wednesday"),
THURSDAY(4,"Thursday"),
FRIDAY(5,"Friday"),
SATURDAY(6,"Saturday"),
SUNDAY(7,"Sunday");

int index;
 String name;

DaysOfWeek(int index, String name) {

this.index = index;
this.name = name;
}

Hashmap →
final Map<Integer,String> DaysOfWeek = new HashMap();
DaysOfWeek.put(1,"Monday");
DaysOfWeek.put(2,"Tuesday");
DaysOfWeek.put(3,"Wednesday");
DaysOfWeek.put(4,"Thursday");
DaysOfWeek.put(5,"Friday");
DaysOfWeek.put(6,"Saturday");
DaysOfWeek.put(7,"Sunday");

For a use case like this, where you typically need to retrieve only
a value based on a key, Enum seems unnecessary.
But consider a case where you want to store multiple related
information corresponding to a single key (more like entity type of
information), you 'll end up with either multiple hash maps or a
map with key and a custom object as the value. In such a use
case, Enum outperforms hash maps.

Case 2 (Complex): Policy related info

You want to store information:
Policy Id (key) → policy title, policy name, policy error code, error
description ..…fields of this kind
id1 → title1, name1, code1, errordesc1
id2 → title2, name2, code2 errordesc2
.
.

Hash maps →
One approach could be store in permutation combination of
simple key-value and navigate through hash maps transitively to
reach the value you are looking for
Example:
map1 <id,title 1>
map2 <id1,errorcode>
map3<errorcode, error description>
.
.

To find an error description of the id you ll look up map1 and then

transitively lookup in map3.
You could solve this with other approaches too, but enum would
be most efficient here

Enum →
public enum PolicyInfo {

POLICY1(1,"tilte1","name1",1001,"e1"),
POLICY2(2,"tilte2","name2",1002,"e2"),
POLICY3(3,"tilte3","name3",1003,"e3");

int id;
String title;
String name;
int errorCode;
String errorDescription;

//constructor
PolicyInfo(int id, String title, String name, int errorCode, String
errorDescription) {
this.id = id;
this.title = title;
this.name = name;
this.errorCode = errorCode;
this.errorDescription = errorDescription;
}

//method to get error description from id

public static String getErrorDesc(int policyId)
{
for(PolicyInfo policyInfo:PolicyInfo.values())
{
if(policyInfo.id == policyId)
 return policyInfo.errorDescription;
}
return "Entry Missing from enum";
}

}//this prints e1 System.out.println(PolicyInfo.getErrorDesc(1));

To conclude, because enum gives you class like features like

constructors and methods, handling complex constant data is
way easier and efficient in an Enum.

[pagina4]
Difference Between EnumMap and HashMap
EnumMap and HashMap both are the classes that implement the Map interface. But there are some
differences that exist between them. So we have tried to list out the differences between EnumMap
and HashMap.

1. EnumMap: EnumMap is a specialized implementation of the Map interface for enumeration

types. It extends AbstractMap and implements the Map interface in Java. Few important points of
EnumMap are as follows:
 EnumMap class is a member of the Java Collections Framework and it is not synchronized.
 EnumMap is an ordered collection, and they are maintained in the natural order of their
keys(the natural order of keys means the order on which enum constant are declared inside
enum type).
 EnumMap is much faster than HashMap.
 All keys of each EnumMap instance must be keys of the same enum type.
 EnumMap doesn’t allow inserting null key if we try to insert the null key, it will
throw NullPointerException.
 EnumMap is internally represented as arrays therefore it gives the better performance.

2. HashMap: HashMap is a class that implements the Map interface. It stores the data in the key and
value pair, where the key should be unique. If you try to insert the duplicate key, it will replace the
element of the corresponding key. It allows to store the null keys as well as null values, but there
should be only one null key and multiple null values. Java HashMap is similar to HashTable, but it is
synchronized. HashMap doesn’t maintain the order that means it doesn’t guarantee any specific order
of the elements.
Pagina 5]
Difference between EnumMap and HashMap in Java
EnumMap is introduced in JDK5. It is
designed to use Enum as key in the Map.
It is also the implementation of the Map
interface. All of the key in the EnumMap
should be of the same enum type. In
EnumMap , key can’t be null and any it
will throw NullPointerException.
EnumMap internally using as arrays, this
representation is extremely compact and
efficient.
HashMap is also the
implementation of the Map
interface. It is used to store the data
in Key and Value form. It can
contain one null key and multiple
null values . In HashMap, keys can’t
be a primitive type. Java HashMap
implementation provides constant-time performance for the basic operations (get and put),
assuming the hash function disperses the elements properly among the buckets.

List
ArrayList
 O para inicializar listas se usa:
 List<String> epl=Arrays.asList(“pedro”,”Jesus”,”Maria”);
List<String> epl1=new ArrayList<String>( Arrays.asList(“pedro”,”Jesus”,”Maria”));
ArrayList:ArrayList class is a resizable-array implementation of the List interface. It
implements all optional list operations and permits all elements.

Diferencias entre ArrayList vs Vectores

[…] Las 2 grandes diferencias entre ambos radican en que:
1. Por defecto, el vector incrementa su tamaño al doble de la inicial mientras que el arrayList
solo lo incrementa a la mitad de la inicial
2. Ambos tienen los mismos métodos, pero todos los métodos del vector son sincronizados,
mientras que los métodos del ArrayList no lo son.

Los procesos sincronizados tienen un impacto mayor de costos en el rendimiento, por tanto
usar vectores incurrirá en un mayor costo en el rendimiento que un arrayList. Pero cuando
existe la necesidad de seguridad en subprocesos, lo mejor es el vector.
Nota importante sobre rendimiento: Cuando se use tanto Vector como ArrayList, se tiene que
inicializar la capacidad a la más alta para que el incremento de capacidad (Resize) no sea
mayor y más costoso.

 Pagina https://www.geeksforgeeks.org/vector-vs-arraylist-java/

 Sincronización: El vector esta sincronizado, lo que significa que solo un subproceso a la vez
puede acceder al código, mientras que ArrayList no esta sincronizado, lo que significa que
varios subprocesos pueden trabajar en ArrayList al mismo tiempo. Por ejemplo, si un
subproceso está realizando una operación de agregar, entonces puede haber otro subproceso
realizando una operación de eliminación en un entorno de subprocesos múltiples. Si varios
subprocesos acceden a ArrayList al mismo tiempo, debemos sincronizar el bloque del código
que modifica la lista estructuralmente o permitir modificaciones de elementos simples.
 Modificación estructural significa la adición o eliminación de elementos de la lista. Establecer el
valor de un elemento existente no es una modificación estructural.

Ilustración 1 Thread significa hilo.

 Rendimiento: ArrayList es más rápido dado que no esta sincronizado. Mientras que las
operaciones vectoriales dan un rendimiento más lento ya que están sincronizadas (seguros
para subprocesos), si un subproceso funciona en un vector, ha adquirido un bloqueo en el, lo
que obliga a cualquier otro subproceso que desee trabajar en él a esperar hasta que se libere
ese bloqueo. Es precisamente ese bloqueo que genera un gasto de recursos adicionales.
 Crecimiento de datos: ArrayList y Vector creen y se reducen dinámicamente para mantener
un uso óptimo del almacenamiento, pero la forma en que cambian de tamaño es diferente.
 Recorrido: Vector puede usar tanto Enumerator como Iterator para recorrer elementos
vectoriales, mientras que el ArrayList solo puede usar Iterator.
 Aplicaciones: La mayoría de las veces, se prefiere ArrayList a Vector porque ArrayList se
puede sincronizar explícitamente mediate Collections.synchronizedList para darle a los
subprocesos del ArrayList seguridad. Cabe aclarar que el vector se sincroniza en cada
operación y no en toda la instancia Vector en sí (como lo hace el arrayList), lo que la
hace insegura ante subprocesos.
 Los vectores son muy lentos ya que están sincronizados, y un solo subproceso puede
obtener un bloqueo en una operación, haciendo que otros subprocesos esperen hasta que
se libere ese bloqueo. ArrayList , por otro lado, es mucho más rápido que a Vector ya
que no está sincronizado y varios subprocesos pueden operar en él al mismo tiempo.

¿Cuándo usar ArrayList y Vector?

 ArrayList no está sincronizado y no es seguro para subprocesos, mientras que los vectores si lo son,
por eso Vector es útil cuando la seguridad en el subproceso es una preocupación. Por tanto, en caso
de un subproceso único, ArrayList es la opción obvia, pero cuando se trata de subprocesos múltiples,
los vectores suelen ser preferibles.
 Si no sabemos cuantos datos tendremos,Vector tiene una ventaja ya que podemos establecer el valor
de incremento de la capacidad de los vectores.
Vector
Vector:Vector is very similar to ArrayList but Vector is synchronised and slow. It is a legacy class.
ArrayList is preferred.
1. Sincronización: En cuanto a la sincronización, Vector es una clase sincronizada, lo que significa
que es segura para usar en entornos concurrentes donde varios hilos acceden y modifican la
lista al mismo tiempo. Esto se logra mediante el uso de bloqueos internos para garantizar que
solo un hilo pueda acceder a la lista en un momento dado. Por otro lado, ArrayList no es
sincronizada, lo que significa que no proporciona ninguna garantía de seguridad para el acceso
concurrente. Si necesitas trabajar con hilos concurrentes, deberías usar Vector o aplicar tu
propia sincronización externa al usar ArrayList.
2. Rendimiento: Debido a la sincronización incorporada, Vector puede ser más lento en
escenarios de un solo hilo en comparación con ArrayList. La sincronización implica una
sobrecarga adicional para adquirir y liberar bloqueos. Por otro lado, ArrayList no tiene esta
sobrecarga y, por lo general, es más rápido en operaciones de lectura y escritura en entornos
de un solo hilo.

Los vectores también implementan la interfaz Lista (ver img). Como ArrayList,
también mantiene la inserción por orden pero nunca es usada en un entorno sin
subprocesos, y como es sincronizado da pobre rendimiento en buscar, añadir,
eliminar y actualizar sus elementos.

Nota importante: Los arrays al definir el tamaño, se llenan de ceros. Los vectores
y las instancias de List, NO!. Son de tamaño de los elementos que tiene, pero el
capacity() si hace q el tamaño varie.

LinkedList
Linked list: A linked list is a sequence of
nodes in which each node is connected to
the node following it. This forms a chain-link of data storage. It consists of data elements and a
reference to the next record.

Doubly-LinkedList: LinkedList class is a doubly-linked list implementation of the List and

Deque interface. A LinkedList stores its data as a list of elements and every element is linked to
its previous and next element.

Stack
Stack: a stack is LIFO data structure in which only the top element can be accessed. The data is
added by push and removed by pop on top. Stack class extends Vector class with five
operations to support LIFO (Last In First Out). Stack internally has a pointer: TOP, which refers to
the top of the Stack element
Tree
Tree: A tree is a collection of nodes connected by edges. Each node points to a number of
nodes. A tree represents the hierarchical graphic form.

Binary Tree
Binary tree: A binary tree has 1 or 2 nodes. It can have a minimum of zero nodes, which occurs
when the nodes have NULL values.

Binary Search Tree

Binary search tree: A binary search tree (BST) is a binary tree. The left subtree contains nodes
whose keys are less than the node’s key value, while the right subtree contains nodes whose
keys are greater than or equal to the node’s key value. Moreover, both subtrees are also binary
search trees. A binary search tree can retrieve data efficiently.
Graph
Graph: A graph contains a set of nodes and edges. The nodes are also called vertices. Edges are
used to connect nodes. Nodes are used to store and retrieve data.

Hash Table
Hash table: Hash table is a data structure that can map keys to values. A hash table uses a hash
function to compute a key into an integer (hash value), which indicates the index of the butckets
(aka array). From the key, the correct value can be stored and found. Hash table is one of the
most used data structures.
Hashtable class is similar to HashMap. It implements Dictionary. Hashtable provides an
Enumeration of its keys. It doesn’t allow null as key or value. Please note that since HashMap
TreeSet
TreeSet: TreeSet is implemented using a tree structure. The elements in a TreeSet are sorted.
The complexity of operations is O(logn).

LinkedHashSet
LinkedHashSet: LinkedHashSet maintains the insertion order. Elements get sorted in the same
sequence in which they have been added to the Set. The complexity is the same as HashSet
O(1).

Queue
Queue: A queue is FIFO data structure. In this structure,
new elements are inserted at one end and existing
elements are removed from the other end.
Priority queue:
Priority queue is a queue, with each element having a priority associated with it. The
implementation can use ordered array, unordered array, and heap.

General Methods of Queue

 .poll()  Se utiliza en el contexto de las estructuras de datos tipo cola, como
Queue o Deque, para eliminar y devolver el elemento en la parte frontal de la
cola, si la coa no está vacía. Si la cola está vacía, el método poll() devuelve null.

Iterator
Recorrer una colección usando Interfaz Iterator<E> de la API de JAVA.--
>Consturir un objeto iterador encargado de recorrer elemento por elemento sin
importar el tipo de elemento que este recorriendo.
o next()Saltar al siguiente elemento de la colección.
o hasNext()Devuelve un boolean.
o remove()
o iterator() Set of elements of the generic given.
En resumen, sería más facil usar un forEach donde SOLO SE RECORRE.
o Pero entonces si quisieras eliminar un objeto de una colección mientras lo
recorres habría un problema de concurrencia
java.util.ConcurrentModificationException
DDBB
JDBC  Java DataBase Connection es una API (Controlador) que permite
realizar operaciones a base de datos independiente del sistema operativo ó base
de datos a la cual se accede.
o Se representa como una colección de interfaces Java y métodos de
gestión de manejadores de conexión. Para poder usarla, el usuario ejecuta
su programa junto con la biblioteca de conexión apropiada al modelo de su
base de datos y los parametros de conexión especificos.
o Cada SGDB tiene su driver JDBC.
o ProgramaAPI JDBC Driver JDBCAPI SGDB  SGBD.

- Que NO se te olvide el driver de el SGBD (Ejemplo el Driver de Oracle es

ojdbc6 ó ojdbc14).
- ResultSetDonde se guardan los resultados de las queries realizadas a la
BBDD.

ODBC Open DataBase Connectivity es un API de acceso a las bases de

datos. Objetivo? Hacer posible el acceder a cualquier dato desde cualquier
aplicación, sin importar qué SGBD almacene los datos. ODBC logra esto al
 insertar una capa intermedia denominada “nivel de interfaz de Cliente SQL
(CLI)” entre la app y el SGBD. El proposito de esta capa intermedia es traducir
las consultas que realiza la aplicación en lenguaje que el SGBD entienda.
JDBC  Es una API inspirada en el ODBC, que permite la ejecución de
operaciones sobre bases de datos independiente del SO o BBDD que se
conecte desde JAVA.

Concluyendo:

Además existen 4 tipos de drivers; el que más usamos nosotros es el Tipo 4

(Drivers Java) Driver que se comunica directamente con la bbdd.
ORM (Object-Relation Mapping)
Un ORM es un modelo de programación que permite mapear las estructuras de una base de
datos relacional (SQL Server, Oracle, MySQL, etc.), en adelante RDBMS (Relational Database
Management System), sobre una estructura lógica de entidades con el objeto de simplificar y
acelerar el desarrollo de nuestras aplicaciones.
Las estructuras de la base de datos relacional quedan vinculadas con las entidades lógicas o
base de datos virtual definida en el ORM, de tal modo que las acciones CRUD (Create, Read,
Update, Delete) a ejecutar sobre la base de datos física se realizan de forma indirecta por
medio del ORM.
La consecuencia más directa que se infiere del párrafo anterior es que, además de “mapear”,
los ORMs tienden a “liberarnos” de la escritura o generación manual de código SQL (Structured
Query Language) necesario para realizar las queries o consultas gestionar la persistencia de
datos en el RDBMS.
Así, los objetos o entidades de la base de datos virtual creada en nuestro ORM podrán ser
manipulados por medio de algún lenguaje de nuestro interés según el tipo de ORM utilizado,
por ejemplo, LINQ sobre Entity Framework de Microsoft. La interacción con el RDBMS quedará
delegada en los métodos de actualización correspondientes proporcionados por el ORM. Los
ORMs más completos ofrecen servicios para persistir todos los cambios en los estados de las
entidades, previo seguimiento o tracking automático, sin escribir una sola línea de SQL.
JPA (Java Persistence API)
 La persistencia de datos es la capacidad de mantener X información por Y tiempo.
 Mapeo Objeto-Relacional (ORM) : Convertir datos del sistema de tipos del lenguaje
de proramacion a objetos usados por las bases de datos relacionales. Convierte los
objetos de la app desarrollada en registros que puedan ser almacenados en una base
de datos.
 La herramienta más útil de Mapeo objeto-relacional es Hibernate, que facilita el mapeo
de atributos en una base de datos tradicional, y el modelo de objetos de un
aplicación mediante archivos declarativos o anotaciones en los beans de las entidades
que permiten establecer estas relaciones. Todo lo dicho, que suena a vendedor de
seguros, se resume en que agiliza la relación entre la aplicación y nuestra base de
datos SQL, de un modo que optimiza nuestro flujo de trabajo evitando caer en código
repetitivo.
 Imagina un programa sencillo. Necesitas un método que permita dar de alta, baja, o
modificar los datos de usuarios. Estos datos se almacenan en una base de datos, y
cada objeto tiene diferentes clases. Para cada objeto debemos crear una clase que al
menos permita crear, insertar, eliminar, consultar o modificar la información contenida
en sus atributos. Esto, con excepción de alguna consulta un poco especial, es siempre
 lo mismo (SELECT, UPDATE, CREATE, FROM, WHERE, GROUP BY, ORDER BY y
etc). Y no sé tú, pero no me gusta desperdiciar mi café en esas tareas cuando debo
preocuparme de las consultas especiales que es donde suele estar el tomate.

Pregunta: el de guardar un usuario en la tabla Users. La verdad, no se si esto

tenga relación directa de cuando yo cree alguna vez la clase Repositorio y
heredaba de esta JPA. ¿Tiene esto alguna relación con el tema q estamos
hablando?

Hiberntae es una herramienta de ORM (Mapeo Objeto-Relacional) que simplifica el proceso de

almacenar objetos de Java en una base de datos relacional. En lugar de escribir consultas
manualemnte, Hibernate se encarga de mapear los objetos JAVA a tablas de base de datos y
generar automaticamente las consultas SQL necesarias.

Cuando utilizas Hibernate para guardar un usuario en la tabla "Users", sigues los siguientes
pasos:
1. Definición de la clase de entidad: Creas una clase Java llamada "User" que
representa un usuario en tu aplicación. Esta clase tiene atributos como el
nombre de usuario y la contraseña.
2. Mapeo de la clase de entidad: Utilizas anotaciones de Hibernate en la clase
"User" para especificar cómo se debe mapear a la tabla "Users" en la base de
datos. Por ejemplo, puedes utilizar la anotación @Entity para indicar que la clase
es una entidad y la anotación @Table para especificar el nombre de la tabla.
3. Configuración de Hibernate: Configuras Hibernate para establecer la conexión
con la base de datos y otras propiedades, como el nombre de usuario y la
contraseña.
4. Guardar el usuario: Creas una instancia de la clase "User", estableces sus
atributos y utilizas una sesión de Hibernate para guardar el objeto en la base de
datos. Hibernate se encarga de generar automáticamente la consulta SQL
correspondiente para insertar los datos en la tabla "Users".
JPA es una especificación estandar de JAVA para el mapeo objeto-relacional y Hibernate es una
implementacion (de muchas) de dicha especificación. Cuando se define una clase Repositorio
que hereda de JPA, estas usando la abstraccion proporcionada por JPA para interactuar con la
capa de persisntencia de datos, y Hibernate actua como implementación concreta de JPA que
realzia operaciones de persistencia en la base de datos.

En conclusión…
  JPA (Java Persistence API) es una especificación estándar de Java para el mapeo objeto-
relacional. Proporciona una interfaz común y un conjunto de anotaciones para interactuar con
bases de datos a través de objetos Java. JPA define cómo se deben realizar las operaciones de
persistencia, como guardar, actualizar y recuperar objetos en una base de datos relacional.
 Hibernate es una implementación popular y ampliamente utilizada de la especificación JPA.
Hibernate ofrece un conjunto de clases y herramientas que implementan los conceptos
definidos por JPA. Actúa como una capa de abstracción entre la aplicación y la base de datos,
permitiendo que los objetos Java se almacenen y recuperen fácilmente en una base de datos
relacional.
 El repositorio JPA es una abstracción adicional que se puede utilizar junto con Hibernate y JPA.
En lugar de trabajar directamente con las clases y métodos de Hibernate, el JPARepository ó
CrudRepository proporciona una interfaz simplificada y consistente para realizar operaciones
de persistencia en la base de datos. Al definir una clase de repositorio que hereda de las
interfaces proporcionadas por JPA, puedes aprovechar los métodos predefinidos para realizar
operaciones comunes, como guardar, actualizar y eliminar entidades.

En resumen, al utilizar Hibernate con JPA, estás utilizando la implementación Hibernate para cumplir
con la especificación JPA. El repositorio JPA es una abstracción adicional que se puede utilizar para
simplificar y estandarizar las operaciones de persistencia en la base de datos. Esto permite una mayor
flexibilidad y portabilidad en tu código, ya que puedes cambiar fácilmente la implementación
subyacente (por ejemplo, cambiar de Hibernate a otra implementación JPA) sin tener que modificar
significativamente el código de la aplicación.

Entiendo lo que ya habías hecho pero con un mayor nivel de conocimiento:

Sí, el CRUD Repository es una interfaz proporcionada por Spring Data JPA que simplifica la
implementación de operaciones CRUD (Crear, Leer, Actualizar y Eliminar) en una base de datos
relacional a través de JPA. Aunque JPA en sí mismo es una especificación y no una implementación, es
común utilizar Hibernate como la implementación subyacente de JPA en proyectos de Spring.

El CRUD Repository se integra con Hibernate (o cualquier otra implementación de JPA) para
proporcionar métodos predefinidos que realizan operaciones de persistencia en la base de datos. Estos
métodos incluyen guardar (save), actualizar (update), eliminar (delete), y buscar por identificador
(findById), entre otros. Al extender el CRUD Repository en una interfaz personalizada para una entidad
específica, obtienes estos métodos CRUD predefinidos sin tener que escribir el código manualmente.

La interfaz CRUD Repository abstrae los detalles de cómo se realiza la persistencia en la base de datos,
lo que te permite trabajar con entidades y realizar operaciones CRUD de manera sencilla y consistente.
Además, puedes definir tus propios métodos personalizados en la interfaz CRUD Repository,
aprovechando la convención de nomenclatura para que Spring Data JPA genere la implementación
correspondiente.

En resumen, CRUD Repository es una interfaz proporcionada por Spring Data JPA que simplifica la
implementación de operaciones CRUD en una base de datos relacional a través de JPA. Aunque puede
funcionar con cualquier implementación de JPA, es comúnmente utilizado con Hibernate en proyectos
de Spring.

Comparator
 Para cuando quieras extraer datos por ciertas condiciones como ordenados por mayor, menor
edad o por cualquier otra condición, se hace necesario usar la interfaz Comparator que no es
más que una función lambda con 2 valore a comparar (Según el orden que se ponga, arroja
inversamente).

Regex
Pattern, Matcher, .find()
 Pattern Definir un patrón de búsqueda de texto usando regex.
 MatcherAplicar ese patrón y buscar coincidencias.
 find() Encontrar la próxima coincidencia del patrón en la cadena.
 Regex secuencia de caracteres que forma un patrón de busqueda, cadena de
texto q facilia la búsqueda en otras cadenas de texto.
Si la regex se complica, el resultado estará a favor de Pattern. Es recomendable usar Pattern
cuando tenemos un procesamiento de datos masivos, regex complejos

 En el siguiente código:
 Se crea un objeto de tipo “Pattern”. El argumento pasado al metodo
compile es la regex q se usará como patrón para realizar la división.
 Se llama al método .split() del objeto “Pattern”.

 Comodín:

 Modificar varias palabras a la vez es posible en un String:

Flags of Patterns
[Pending]
Effiency

 Complejidad temporal: Tiempo lineal O(n), nos referimos al tiempo que tarda en ejecutarse
en funcion del tamaño de entrada . Significa que el tiempo de ejecución del algoritmo aumenta
linalemnte con el tamaño del input. Es decir, si duplicamos el tamaño del input, el tiempo de
ejecución se duplicaría.
 Complejidad Espacial: Se refiere a la cantidad de memoria q requiere el algoritmo para
funcionar en funcion del tamaño de la entrada (n). Si es O(1) significa que usa una cantidad
fija de memoria independiente del input ingresado.
 Big O  Medir la eficiencia de un algoritmo. Nos indica como crece el tiempo de ejecución o
cantidad de recursos (ej. Memoria) a medida que aumenta el tamaño del problema o input.

Runtime y Memory
RuntimeTiempo de ejecución de un programa dentro de un SO. Depende en gran medida de
las estructuras de datos y algoritmos que implementemos.
Memory  Memoria que se tiene para los datos y el programa en ejecución. Trata de no
agotar los recursos del sistema usando mucha memoria y liberarla en caso de que sea
necesario.
 Liberación de memoriaUn ArrayList no es más q un array pero dinamico. La
memoria de este crece un 50% más que la anterior. Liberar esa memoria podría llegar
a ser eficiente.
 Cerrar conexión a bbdd, des-subscripción a observables, objetos y matrices
grandes.

Complexity Time and Memory (Big O)

 Complejidad de un algoritmo: Ej: un algoritmo de busqueda y queremos ver
que tan rapido es para buscar, NO podemos definirlo sobre el tiempo, MAC vs
Celular. Por otra lado, el comportamiento cambia su comportamiento
dependiendo de la cantidad de datos a buscar (algunos algoritmos funcionan
muy bien con pocos datos y otros con muchos datos). Si queremos expresar el
que tan bueno es un algoritmo para ciertos casos y no para otros. NO lo
podemos representar con tiempo y hay q considerar la cantidad de datos y su
comportamiento de como va creciendo.
 O  Describe rendimiento y comportamiento de un algoritmo. Suele indicar el
tiempo de ejecución requerido o la memoria q el algoritmo necesita confome
aumenta el input. Complejidad conforme el tamaño o input va creciendo, es
decir, como el conjunto de tamaño de conjunto de datos afecta el rendimiento del
algoritmo.

 O(1) el ratio de crecimiento de Orden 1. Indica tiempo constante, lo que significa

que el algoritmo se ejecutará con el mismo rendimiento sin importar el tamaño
del input. La n representa el tamaño de un conjunto, como el tiempo de
ejecución depende del input, por eso esta allí.
 O(n)  El crecimiento en complejidad del algoritmo es proporcioanl al tamaño
input.
 O(n2)  Indica que el crecimiento de la complejidad es proporcional al cuadrado
del input. (Doble iteración= 2 for) . Entre más crezca la entrada, peor se
comportará.
 O(logn)  Reduce su complejidad cuando el tamaño va creciendo

 Nuestros clientes: ¿Cuánto se tarda en procesar todos los documentos? ¿Qué

tanta memoria ocupa? ¿Qué tantos servidores necesito pa aguantar todo ese
trafico?--> Notación de Big O.

 Algoritmo:

Velocidad: Ej: sin impiortar la entrada, numero de libros, siempre me

demoro lo mismo en llegar. El tiempo se mantiene constante. Ej: un corredor se
demora 1s en 100 m, 2s en 200m, es decir que el tiempo crece linealmente.
Dependiendo de la entrada.
Lo que nos permite es representar la tasa de crecimiento de un algoritmo.

Memoria:

 En el siguiente ejemplo, la variable “c” no varía con la entrada, por tanto se

considera de tiempo constante.
 Sumas las complejidas y sumarlas. Y tomaremos el más signficaitivo,
quitando cualquier constante. Ej: 2n2 +n+1  n2 , por tanto el algoritmo en
conjunto tendría una complejidad de O(n2)
 Complejidad Temporal:
 La complejidad temporal se refiere al número de operaciones o instrucciones ejecutadas por el
algoritmo en función del tamaño de la entrada (si existe).
 Complejidad Espacial:
 La complejidad espacial se refiere a la cantidad de memoria utilizada por el algoritmo en
función del tamaño de la entrada.
Ordering in JAVA

Quick Sort
* Divide y vencerás:
* Dividir--Arreglar--combinar.
*
* CONCEPT: PIVOTE.
* 1. Se elige un pivote al azar.
* 2. Ordenar los elementos dependiendo si son mayores o menores q el pivote:
* si un elem es menor q el pivote, va a la izquieda, si es mayor a la
derecha.
* 3. Tendríamos 2 indicadores( Ind.Izq e Ind.Dere) q iremos comparando con el
pivote.
* 4. En el Ind.Izq cuando encuentre un número mayor quel pivote, pararía y
seguiriamos con el Ind.Der encontrando
* numeros menores o iguales q el pivote.
* 5. Cuando estén en la misma posición, intercambiaríamos las posiciones.
* 6. Seguiría buscando por la izquierda e derecha los numeros.
*
*
 * 1. Elegir un pivote al azar.
* 2. Clasificar en 2: 1. Superiores 2. Inferiores.
* 3. Elegir el pivote del 1.Superiores
* 4. Clasificar en 2: 1. Superiores y 2. Inferiores
*
* IMPORTANT: Choose a right PIVOT!

1. public static void quickSort(int A[], int izq, int der) {

2.
3. int pivote=A[izq]; // Tomamos el primer elemento como pivote.
4. int i=izq; // i realiza la búsqueda de izquierda a derehca
5. int j=der; // j realiza la búsqueda de derecha a izquieda.
6. int aux;
7.
8. while(i<j) { // Mientras no se crucen
las búsquedas.
9. while(A[i]<=pivote && i<j) i++; // Busca elemento mayor que pivote
10. while(A[j]>pivote) j--; // Busca elemento menor que
pivote.
11. if(i<j) { // Si no se han
cruzado aún,
12. aux=A[i]; // los
intercambiamos.
13. A[i]=A[j];
14. A[j]=aux;
15. }
16. }
17. A[izq]=A[j]; // Se coloca el pivote en su lugar de forma que tendremos
18. A[j]=pivote; // los menores a su izquierda y los mayores a su derecha.
19.
20. if(izq<j-1)
21. quickSort(A, izq, j-1); // Ordenamos subarray izquierdo
22. if(j+1<der)
23. quickSort(A, j+1, der); // Ordenamos subarray derecho
24.
25. }
26.

Merge sort
Si necesitaramos ordenar una colección de números, el MergeSort sería más
eficiente.
 MergeSort y BST son eficientes para tareas de búsqueda y ordenamiento de
datos y la tarea de encontrar el valor máximo de una colección de números no
requiere ordenar o buscar datos.

Best Practices

 Decrease a number
Reducción de if - else if - else
 Guard classes  Clausulas de guarda. No hay q esperar a que se den las
cosas una tras otras como cadenas, si NO se da una, pues chao pescado, para
que seguir leyendo linea por linea.

Nota de buenas practicas  Existe una sola clase con el listadoDeLegisladores en donde se
encuentran los distintos metodos:
o 1. Constructor inizializando lista.
o 2. Añadir elemento a lista.
o 3. Imprimir lista:
 Iterator<Legislador> recorre= lista.iterator();
 While(recorre.hasNext()){
 Legislador aux= recorre.next();
 syso(aux.toString());
Refactoring
Para mejorar la legibilidad y mantenimiento del Código. Para esto se puede ver dando click
derecho en Refactor.
Ejemplo1: En vez de estar evaluando, pues crear un método q evalué cada condición y el
resultado se evalúa en otra expresión. Y con el nombre del método ya nos indica que se está
evaluando.
Claro, la función SOLO debe hacer lo que dice su nombre que hace( en ese caso estaba
calculado y verificando (cosa que NO deberia hacer).
Buena tecnicaAlmacenar codigo dentro de variables booleanas así se evita el uso constante

de if-else if- else

Ejemplo 2: No repetir código o mensajes!

Ejemplo 3: Cuando las clases crecen y crecen de atributos, es mejorar separarlas o

desacoplarlas:
 Ejemplo 4: Cálculos muy largos,
desacoplarlos en funciones (en Refactor es
Asignar Variable) que sean entendibles y que
den indicio de algo.

* Hacer código más fácil, legible, mantener,etc. Que reduzca su Deuda técnica.(acumulación de malas
prácticas , el código hace lo q tiene q hacer pero de mala manera… todos los días si no se corrige, con buenas
prácticas, el código al cabo de un tiempo sea inservible ya que al realizar cambio el coste sea tan alto que sería
mejor empezar de 0)
Técnicas para reducir la complejidad del código.
MantenimientoCuanto cuesta introducir un nuevo cambio o mantener un código da mayores costos
derivados de la deuda técnica, con demasiado código que se puede de mantener.
Hacer lo mismo pero mejor.
IMPORTANTE -ser bastante descriptivos con los nombres de los métodos! Si va a realizar una
acción, usar como prefijo la acción:
GetHTML
findAll
getName
BUENAS PRACTICAS- Al usar _ , lo ideal sería que todo el nombre de la variable estuviera en
Minúsculas!!!
RecoderisUna de las buenas prácticas de programación(Refactoring) es no modificar los
parámetros que recibe una función (que vengan como tengan que venir).

System.out.println VS Log Framework

 1. Log Retention and Retrieval: Dedicated logging frameworks allow you to configure log levels
and destinations. This means you can control where log messages go and for how long they
are retained, making it easier for users to retrieve logs when needed.
2. Uniform Formatting: Dedicated loggers provide options for defining log formats, including
timestamps, log levels, and other metadata. This uniform formatting makes it easier to read
and analyze logs, which is crucial for debugging and monitoring.
3. Recording Logged Data: Logging frameworks typically provide features to ensure that logged
data is recorded consistently and reliably, even in the event of errors or exceptions.
4. Security: Log data can sometimes contain sensitive information, so it's important to handle it
securely. Logging frameworks often provide mechanisms for securing sensitive data in logs,
such as masking or encrypting it.
5. Flexibility: Logging frameworks offer more flexibility in terms of routing logs to different
outputs, like files, databases, or external services. This can be important for different
deployment scenarios.

Java’s Concepts
JDK (Java Development Kit)
- Conjunto de herramientas que permite desarrollar y compilar programas en el lenguaje de
Java. Crear, depurar y ejecutar apps java.
o Contiene el compilador java Traducir el codigo fuente en lenguaje que la JVM
entienda y esta ejecuta (BytesCode).
o Bibliotecas de clases.
o Depurador.

JRE (Java Runtime Environment)

- JRE  Java Runtime Envionment  Incluye la JVM, bilbiotecas etc para EJECUTAR
JAVA.
- Una proporciona herramientas para desarrollar y otro para ejecutar.
Diferencia entre URL, URN & URI

URI (Uniform Resource Identifier): URI es un término genérico que se utiliza para identificar de
manera única un recurso en la web. Puede ser una cadena de caracteres que proporciona una
dirección para acceder a un recurso en línea. Las URIs pueden ser de dos tipos principales: URL
y URN.
URL (Uniform Resource Locator): Una URL es un tipo de URI que no solo identifica un recurso,
sino que también proporciona información sobre cómo acceder a ese recurso. Una URL consta
de varios componentes, como el esquema (protocolo), el nombre de dominio, el puerto
(opcional), la ruta y los parámetros. En resumen, una URL es la dirección completa para
acceder a un recurso en la web. Ejemplos:
URL: https://www.ejemplo.com/pagina
URL: ftp://archivos.ejemplo.net/documento.pdf
URN (Uniform Resource Name): Una URN es otro tipo de URI que se utiliza para identificar un
recurso sin indicar cómo acceder a él. A diferencia de una URL, que proporciona la ubicación
física del recurso, una URN se centra en darle un nombre único al recurso.
 URI: Término genérico para identificar recursos.
 URL: Identifica un recurso y proporciona la forma de acceder a él.
 URN: Identifica un recurso por su nombre único, sin especificar cómo acceder a él.
Java’s data type

 Si es de tipo Float, se pone un sufijo “j”. Lo mismo pasa con Double “d”.
 Las fechas son objetos de la clase Date.
Importance of selecting good type of data.
 VariableEspacio en la memoria del ordenador donde se almacenará un valor
que podrá cambiar. La memoria RAM, es una memoria volatil (que lo q se
almacene, se borra cuando se apaga el computador).
 o Para que usa el PC la RAM?--> Simplemente arrancar el computador, va
ocupando espacio memoria RAM. Mientras vas abriendo programas, esa
memoria RAM la va ocupando porq el ordenador la usa para procesos
internos de manejo de apps y procesos en segundo plano.

 Entramos en parte de la memoria RAM. Que pasa cuando declaramos una

variable?-->Reservamos un espacio en la memoria RAM del ordenador.
 Y cuando la llenamos, ponemos ese dato en ese espacio reservado.
 Ojo con la declaración de variables, estaríamos desperciando memoria que tal
vez necesitemos:

 Reservar más espacio en memoria de lo normal, sería desperciar recursos del

computador.
RAM
Memoria volátil y de acceso rápido para almacenar temporalmente datos e instrucciones que
son activamente usados por el procesador. Contiene información necesaria para llevar a cabo
ejecución de programas.
Cuando se abre una app, los datos necesarios se cargan desde el almacenamiento de largo
plazo a la RAM.
Cuanto mayor sea la RAM, mas operaciones o multitareas, etc. Podrá realizar de manera
concurrente multiples tareas, ejecutar programas, etc.
Big Decimal
Trabajo con números grandes o q requieren alta precisión.

Classpath
Error: Could not find or load main class
Este error ocurre cuando la JVM no encuentra la clase principal a ejecutar. Por tanto, hay q
cambiar el classpath.
ClasspathLocalizar clases y librerias usada por la JVM para ejecutar
programas de java.

Buildpath
Buildpath  Especifica la localizacion de codigo externo y librerias que el IDE
usa durante compilacion y desarrollo.

Diferencias entre Python y Java

Los compiladores e intérpretes toman código legible por los humanos y lo
convierten en código máquina legible por computadoras.

En un lenguaje compilado, la máquina de destino traduce directamente el

programa. En un lenguaje interpretado, el código fuente no es directamente
traducido por la máquina de destino. En cambio, un distinto programa, mejor
conocido como intérprete, lee el código y lo ejecuta. Ejemplo de la receta.

Lenguajes compilados
Los lenguajes compilados son convertidos directamente a código máquina que el
procesador puede ejecutar. Como resultado, suelen ser más rápidos y más
eficientes. Si cambia algo, necesita ser recompilado.

Lenguajes interpretados
Estos lenguajes ejecutan línea por línea el programa y a la vez ejecutan cada
comando. Este suele ser más lento debido a que el proceso de traducción del
código en tiempo de ejecución aumenta la sobrecarga y puede ocasionar que el
programa sea más lento en general.

La principal diferencia entre un lenguaje compilado y uno interpretado es que el lenguaje

compilado requiere un paso adicional antes de ser ejecutado, la compilación, que
convierte el código que escribes a lenguaje de máquina. Un lenguaje interpretado, por
otro lado, es convertido a lenguaje de máquina a medida que es ejecutado.

La diferencia con los lenguajes compilados radica en que el programa de un lenguaje compilado está
representado por el archivo ya escrito en binario que, una vez lanzado, se lee directamente y se ejecuta. En los
idiomas interpretados, el programa está representado por el código fuente que primero se traduce y luego se
compila cada vez, con la consiguiente disminución del rendimiento. Sin embargo, esto permite una mayor
simplicidad en términos de sintaxis, como se muestra al principio con python, pero sobre todo permite que el
programa se ejecute en cualquier máquina con cualquier sistema operativo.

Java
Algunos lenguajes, como Java, se compilan en un lenguaje intermedio como, en este caso, el Bytecode que
luego se interpreta en instrucciones para el procesador gracias a la Java Virtual Machine. Esto te permite tener
archivos ligeros, Bytecode genera archivos pequeños, pero también te permite ejecutar el programa en cada
máquina gracias a la intervención de un sistema de interpretación que no depende de la máquina.

https://aulab.es/noticia/18/diferencia-entre-lenguajes-de-programacion-compilados-e-interpretados
Por regla general los lenguajes interpretados son portables, mientras los
lenguajes compilados son dependientes en gran medida de la arquitectura del
sistema sobre el que se ejecutan, normalmente se requerirá un compilador para
Windows, otro para Unix, otro para macOS y así sucesivamente.

Una vez que se cuenta con la aplicación, a partir de nuestro código fuente se generará un ByteCode
(el equivalente al Código Objeto de los lenguajes compilados) el cual es independiente de la
plataforma, el cual contiene las instrucciones que se deberán ejecutar. Sin embargo el ByteCode no
puede ser ejecutado directamente, requiere una base sobre la cual "montarse" para poderse
desplegar. Esta base es una Máquina Virtual.

Maquinas Virtuales

Una Máquina Virtual es una abstracción que crea una interface entre un hardware
específico y un software de aplicación de código intermedio o ByteCode.

Es decir es un software especial que sirve para ejecutar aplicaciones de ByteCode en un

determinado equipo físico. La principal ventaja que obtenemos con esto es que se
pueden desplegar aplicaciones y sistemas completos independientes del hardware
sobre el cuál se ejecutarán, solo basta con contar con la máquina virtual para el sistema
que querramos utilizar. Si después queremos ejecutar esa aplicación en un equipo
completamente distinto solo deberemos obtener la máquina virtual para ese sistema
particular.

Tal vez el ejemplo más ilustrativo de una máquina virtual es la Máquina Virtual de Java
(JVM) por su difusión, popularidad y base de programadores existente.

De este modo los programadores de Java solo tienen que escribir su aplicación una vez
y (en teoría) ese programa podrá ejecutarse en computadoras de escritorio, celulares
(sin importar si usan Android, iOS o cualquier otro), autos... cafeteras... mientras tengan
una Máquina Virtual de Java y los recursos del sistema sean suficientes, esto sería

posible.

Bytecodes
 Guardamos cambiosEclipseHa hecho una compilacion del programa Nos genera el
Bytecode (extension .class) este es el archivo que la JVM tiene que interpretarEste es el
autentico archivo multiplataforma (que si le pasamos ese archivo a un compañero que tiene
Mac, Ubuntu, Windows, en cualquiera corre.

Garbage collector
 Todo esto se almacena en la memoria RAM, objetos variables etc. Muchas
veces programas son lentos ya q tenemos objs y etc q no usamos más.
 Es un BARREDOR QUE ESCANEA DINAMIENCATE EN LA MEMORIA
OBJETOS QUE NO ESTÉN REFERENCIADOS.
 Escanea todos los objetos e identifica los que NO ESTÉN REFERENCIADOS.
 “new” reserva alguna localidad de memoria. En realidad, estamos creando un
apuntador que apunta a esa localidad, para empezar a trabajar desde allí. Al
usar los sets, empiezo a usar esa localidad de memoria. Tal como un control
remoto.
  .finalize()  Antes de que un objeto sea recolectado, el Garbage Collector le da
una oportunidad para limpiarse el mismo mediante la llamada al
método .finalize() del propio objeto. Podrías sobre escribir dicho método.
 Es posible llamar explícitamente al Garbage Collector con System.gc(), pero el
que al final decide si es pertinente o no es la JVM. Es bastante costoso esto.

 Nota: Cuando tratamos con datos primitivos, estos se están pasando por valor
más no por referencia.

Ejemplo:
  Al usar los sets, empiezo a usar esa localidad de memoria.
 Personda2=persona1 ( Persona2 apunte a la misma localidad de memoria de
persona1, en donde se encuentra toda la infor de la persona1.)
 Persona1=null Tu ya no apuntes a la localidad1 sino a otro. El único q está
apuntando a esa localidad es Persona2. Si persona2 tambien apuntan a null,
ahora nadie está apuntando a la localidad dondé esta la información del nombre.
Quedá esa información allí sin ningún tipo, por tanto el GARBAGE
COLLECTOR empieza a destruir esos objetos que ya NO ESTÁN
REFERENCIADOS.

It’s a built-in mechanism that automatically manages the memory used by your program. It’s
primary purpose is to identify and reclaim memory that is no loger in use, allowing your
program to effectively use available resources with the need for manual memory management.

Garbage Collection: The Java garbage collector periodically IDENTIFIES and RECLAIMS
memory occupied by unreachable objects. This process ensures that memory is efficiently
managed and that resources are not wasted.

How Garbage Collections Works in Java:

1. Memory Allocation: When you create objects or allocate memory in java, it’s
done using the “new” keyword or other memory allocation methods. The JVM
assings memory for these objects in an area called the heap.
2. Reference Tracking: The JVM keeps track of references to objects in your
program. An object is considered reachable if it can be accessed or reached
through references from other objects, static variables, or methods.
 Unreachable objects are those that are no loger accesible from the promgram’s
execution context.
3. Garbage Collection Process: Periodically or when the JVM determines it’s
necessary, the garbage collector runs to identify and reclaim memory occupied
by unreachable objects.

 Finalize: A garbage collector always calls the finalize method just before it deletes or
destroys an object to perform cleanup activities. The clean-up activity means closing
resources associated with that object, such as databases and network connections, or de-
allocating resources. It is defined in the Object class.

EJEMPLO

1. public class GarbageCollectorExample {

2. public static void main(String[] args) {
3. // Creating two objects and assigning references to them
4. MyClass obj1 = new MyClass();
5. MyClass obj2 = new MyClass();
6.
7. // Nullifying the reference to obj1
8. obj1 = null;
9.
10. // Reassigning obj2 to another object
11. obj2 = new MyClass();
12.
13. // At this point, obj1 is unreachable, and obj2 points to a new object
14. // Garbage collector will collect the unreachable object (obj1) at some point
15.
16. // Explicitly requesting garbage collection (not recommended in practice)
17. System.gc();
18. }
19. }
20.
21. class MyClass {
22. // Constructor
23. public MyClass() {
24. System.out.println("An object of MyClass is created.");
25. }
26.
27. // Finalizer (not recommended for resource cleanup)
28. @Override
29. protected void finalize() {
30. System.out.println("The finalize() method is called.");
31.
32.

In this example:

1. We create two MyClass objects, obj1 and obj2.

2. We then set obj1 to null, making it unreachable. This means that there are no references
pointing to the original obj1.
3. Next, we reassign obj2 to a new instance of MyClass, effectively making the old obj2
unreachable.
4. We explicitly request garbage collection using System.gc(). While you can request garbage
collection, it's not recommended in practice, as the JVM decides when and how to perform
garbage collection.
Here's what happens in terms of garbage collection:

 When obj1 is set to null, it becomes unreachable, and the finalize() method of the original obj1 (if
any) may be called before it's collected.
 The new obj2 now points to a different object, and the old obj2 is also unreachable.
 The garbage collector periodically or when it determines it's necessary, will reclaim the memory
occupied by the unreachable objects (in this case, obj1 and the old obj2). If the finalize() method
is defined for the MyClass objects, it may be called before their memory is reclaimed, though
the order and timing of finalization are not guaranteed.

Remember that garbage collection happens automatically, and developers don't usually need to
explicitly request it. It's the JVM's responsibility to manage memory and clean up
unreachable objects when needed, ensuring efficient memory usage in Java programs.

Memory Allocation
Memory allocation in Java refers to the process of reserving a portion of the computer's
memory (RAM - Random Access Memory) to store data and objects created by a Java program.
Unlike low-level programming languages like C or C++, where developers are responsible for
explicitly allocating and deallocating memory, Java handles memory allocation automatically
through a component known as the Java Virtual Machine (JVM). Here's how memory allocation
works in Java:
  Heap Memory: In Java, most memory allocation occurs in an area of memory
known as the "heap." The heap is a region of memory used for the dynamic
allocation of objects, and it's managed by the JVM.
 Object Creation: When you create an object in Java using the new keyword or
other memory allocation mechanisms, the JVM reserves space in the heap
memory to store the object's data.
 Reference Variables: Objects are accessed and manipulated through reference
variables. These reference variables hold the memory addresses (references) of
objects rather than the actual object data.
 Automatic Memory Management: Java's automatic memory management
system, which includes garbage collection, is responsible for allocating memory
when objects are created and deallocating memory when objects are no longer in
use (i.e., unreachable).
 Garbage Collection: Unreachable objects are automatically identified and
removed from memory by the garbage collector. This process frees up memory
for future object allocations. Developers do not need to explicitly deallocate
memory as they would in languages like C or C++.
 Memory Efficiency: Java's memory allocation and garbage collection
mechanisms aim to optimize memory usage, prevent memory leaks, and ensure
that the program uses available memory resources efficiently. Memory is
allocated on demand as objects are created, and it is released when objects
become unreachable.

Here's a simple example of memory allocation in Java:

API Java

 Java.awt Existen unas clases

 Java.util.regex  Sigue una estructura jerarquica.

 Por defecto, al programar esta implicitamente el paquete Java.Lang. Si

queremos usar otro paquete, hay que importarlo.

Design Patterns
 -
- Ejemplo: Resolver un problema 50 veces. Pues porque no mejor crear una solución en
concreto. Existen actualmente 23, 24 patrones de diseño.
- Objetivos:
o Proponen codigos reutilzables.
o Solucionan que volver a solucionar el mismo problema 20 veces. Patron singleton
dice una clase SOLO pueda tener una instancia)Este problema YA está resuelto.
o Nos entendamos entre desarrolladores.
o Estandarizar el desarrollo y compresión.
o No dar vueltas a la cabeza que ya tienen solución.
- No son objetivos:
o No usarlos a la fuerza. Patrones de diseño son patrones estandarizados.
- Antipatrones:
o Mala practica!
- Patrones:
o Se etiquetan siguiendo una clasificación
 1. Por su nombre unico, ejemplo: factory,adapter.
 2. Que problema pretende resolver? Patron builder cosnturir objetos
complejos.
 Que consecuencias tiene ese patron?
- TIPOS
o 1. CREACIONALES: Ayudan a crear instancias de objetos o envuelven ciertas
informacion. Ejemplo: crear un sistema de creacion de objetos complejos(builder,
factory,prototype, singleton, MVC (Model View Controller), Objetc Pull.
o 2. ESTRUCTURALES: Solucion problemas con diseño de composicon o agregacion
de clase y objetoscohesionan diferentes clases, acopla las clases para que
trabajemos mejor con estas, ejemplo:decorater, facade (ante muchas clases
complejas), wrapper, adapter (clases distintas y las une mediante una clase única,
adaptar códigos ajenas a nuestro, donde no modifiquemos código ajeno).
o 3. DE COMPORTAMIENTO: Solucion entre la interaccion y lo q hace cada clase y
cada objeto. Ejemplo: eventHandlerPatron observer (patron de compor. Es q
reacciona ante algo) cuando un emisor hablar, los receptores reaccionan, nuestro
comportamiento a lo que hace el emisor. Ejemplo: Clase del OpenBootCamp.

Creational patterns
Para crear objetos de una forma mas simple. Ayuda a la creación de objetos o instancias.
Singleton
A class can just has one instance.
* Solo puede haber una isntancia en una clase
* pretende envitar q se crean nuevas instancias. Cuando haga una isntancia una segunda vez
* q opere con la instancia previamente habia operado. No existe ese concepto de "nueva
instancia".
Estan en la misma ubicación de memoria.

USOS:
o Comparitr conexiones a una base de datos,en lugar de q cada clase se
conecte a la base de datos, creamos una instancia de la base de datos,
cuando se haga getInstance, obtengo dicha unica conexión.
o comparitir acceso a un fichero
o evitar la instanciacion de una app multiples veces
o Cualesquiera cosas q necesites una INSTANCIA COMPARTIDA Y EVITAR
que tengamos múltiples instancias de una misma clase. Esto ahorra
recursos porq no estas instanciando una misma clase, comparte.
 o Asegurarse de q en una clase solo haya una sola y única instancia.

Factory
Es cierto que las Factorias se encargan de generar una jerarquía de clases pero su función
fundamental es encapsular una jerarquía de objetos y reducir el conjunto de conceptos con los
que trabajamos.

* Crear una jerarquia de clases y usar una u otra clase de forma transparente.
* Coeccionar una jerarquia de clases en una unica. Tengo las clases PrecioEUR y precioUSD en
una sola q es Precio
1.
UML’s Diagram

Builder
Builder patron nos ayuda Construir objetos complejos paso a paso usando el concepto de
Programación fluida.
2.
3.
 4.

Prototype

* Objetivo-->Clase clonarse a si mismo, y q ese clon heren TODO (PROPIEDADES,

METODOS,ATRIBUTOS), tambien su estado.
* Analogia-->Un molde (un dia le echamos plata liquida, otro dia oro,etc.-->Y si algo corta el
molde, entonces
* los objetos q se creen TODOS salgan cortados.
Behavioral patterns
 Se ocupan de la comunicación y relación entre objetos y clases.

Observer
- Tiene un emisor y múltiples receptores.
- AnalogíaMuchas personas pueden escuchar la radio
- oneToMany (Uno habla muchos escuchan y estos reaccionan)
- También llamado Public Subscriber.
* Se puede llamar como :public subscriber-->Uno emite, se suscriben para reaccionar a un
evento.
* Ejemplo: cuando se suscribe, para tener la ntoificacion de algo haya pasado.
* Se usa mucho y es muy util
* Habla y muchos escuchan-->oneToMany
* Los escuchadores de ese evento escuchan y obedecen. Analogo a una emisora.

[Explicación ChatGPT-3]
El patrón Observer es un patrón de diseño de software que se utiliza para manejar eventos y
cambios en un sistema. Este patrón se basa en la idea de que un objeto, llamado sujeto u
observable, mantiene una lista de sus dependientes, llamados observadores, y les notifica
automáticamente cada vez que se produce un cambio en su estado.
En este patrón, el sujeto u observable es la entidad que tiene el estado que puede cambiar. Los
observadores son las entidades que están interesadas en el estado del sujeto y que necesitan
ser notificados cada vez que se produce un cambio en su estado.
El sujeto u observable proporciona una interfaz para que los observadores se registren y
cancelen su registro. Los observadores implementan una interfaz común que permite al sujeto
notificar automáticamente a todos los observadores registrado cuando se produce un cambio
en su estado.
Este patrón es útil en situaciones en las que múltiples objetos necesitan estar informados de
los cambios en el estado de otro objeto. También permite que los objetos puedan comunicarse
sin conocer los detalles internos del otro.
Por ejemplo, en un sistema de comercio electrónico, el sujeto u observable puede ser una
tienda en línea que mantiene un registro de los productos en inventario. Los observadores
pueden ser varios clientes que están interesados en recibir notificaciones cada vez que se
agrega un nuevo producto al inventario o cuando se elimina un producto existente. De esta
manera, los clientes pueden ser notificados automáticamente cada vez que se produzca un
cambio en el inventario sin tener que realizar consultas repetitivas para ver si ha habido algún
cambio.
 1 Step: Create the subscribers that implement a common interface with the
methods to execute.

 2 step: Create the transmitter with 2 basic methos and just add subscribers:
Iterator

 IteratorImplementar metodos en nuestra clase para recorrer datos sin saber

como estan almacenados(hashamp,linkedlist,array)
 Sea lo que sea, el q esté usando esa clase, que recorra cualquier tipo de
DataStructure. Es decir, el tipo de almacenamiento es indiferente a este patrón
de diseño.

Mediator

* Semaforo-->En lugar de q reine el libre albedria, actuar de mediador y comunicador.

* Meidador de comunicador de objetos. Tenga q 5 clases hablar una con otra, usariamos una
* lase mediadora(soy clase a y quiero hablar con b, la clase b responde al mediador y esta se la
pasa a la clase a).
* Si tenemos muchas clases interdependientes, tenemos una central que se encarga de
realizar posible comunicación.
* El destino se comunica con el mediador y el mediador con el destinario; tambien analogo a
un proxy(haz la
* peticion al proxy y este mismo da la respuesta). Util muchas clases q se comunican entre
ellas.
* En el patron observer solo 1 habla. el patron mediato todos pueden hablar.
* Ejemplo: enviar mensaje por correo, y recibes otro.
* FUNCION: COMUNICAR UNOS OBJETOS CON OTROS(USADO EN INTERFACES DE USUARIOS--
>PULSAR UN BOTON, APARTE DE SALIR UN CUADRO
* DE CONFIRMACION, SE PONGA EL FONDO OSCURO, DESAPARECE EL MODAL,ETC. MULTIPLES
CLASES SE COMUNICEUN DE MANERA DESCENTRALIZADA
* TENEMOS 5 CLASES DIFERENTES Y SE COMUNIQUEN Y SI UNA CAMBIA, NO CAMBIAR LAS
OTRAS 4.

 Paso 1: Crear un mediador para todos que tenga 2 básicas funciones: Registrar
y enviar. Y crear un mediador concreto que implemente dichos métodos y pueda
registrar a los Speakers.

 3 PASO: Crear una clase abstracta del tipo de entidad que quiero que se
comuniquen entre ellas, es este caso, COLEGA, en la que cada colega tiene un
mediador; es algo así como si cada colega tuviera su MEDIADOR con el que se
comunica. Análogo a una centralita.
UML’s Diagram:

State
* FLUJOS DE TRABAJO (Gestionar el Flow Work) Si no pasa una cosa que no pase la
* otra(un dispensador de cocacola si le doy al boton, primero tengo q insertar la moneda para
q asi si me pase la cocacola)
*
* Implementacions una clase abstracta con funciones q permiten cambiar los estados en
cadena. Ejemplo: en moviles se usa.
* Succesion de eventos. Primero hago esto, luego esto y luego esto. Ejemplo: No puedo tomar
foto si tengo el telefono bloqueado.
* Por cada estado heredo la clase base que es Estado. Y en cada estado invoco al constructor
del padre class Estado e implemento los metodos abstractos de dicha clase.

 1 PASO: Creamos la entidad con un atributo llamado Estado y un constructor

que crea un estado inicial.
  2 PASO:

UML’s diagram
Strategy
* Crear un envoltorio sobre varias funciones de forma q un mismo codigo se pueda usar de
maneras diferentes.
* Ejemplo: metodo de pago-->Nos ofrece una serie de opciones. Pero la implementacion de
apgar ocn visa es distinto de pagar con paypal
* Es implmentar unas funciones ismilares(con el mismo nombre), estas actuen de una u otra
forma. Podremos crear metodo pagar en
* 2 clases diferentes dependiendo de por donde vamos a pagar, se ejecute uno o se ejecute
otro. Los metodos y sus nombres son los mismos.
* Teniendo diferetnes clases que implementen una misma interfaz, si creamos sobre ellos un
envoltorio, podemos utilizarlas indistintamente.
 https://refactoring.guru/design-patterns/strategy
Chain of responsibility
Certainly! The Chain of Responsibility is like passing a request along a chain of people until someone can handle it.
Let's break it down in a simple way:

Imagine you work in an office, and you have a series of supervisors, each with a different level of authority. You have
a simple request, like getting approval for a day off. You first ask your immediate supervisor. If they can approve it,
great! If not, they pass it up the chain to their supervisor. This process continues until someone with the authority to
approve your request is found.

Here's why this is useful:

1. No one person is overloaded: If your immediate supervisor is busy or unavailable, the request
automatically goes to the next person in line. This ensures that the request doesn't get stuck, and it finds its
way to someone who can handle it.
2. Flexible and dynamic: The chain can be easily adjusted. If a supervisor is unavailable or if the organization
structure changes, you can still pass requests smoothly.

In programming, the Chain of Responsibility pattern is used similarly. You have a series of objects (like the
supervisors) that can process a request. The request is passed along the chain until one of the objects can handle it.
This makes your code more flexible, as you can add, remove, or rearrange these processing objects without
changing how requests are made. It promotes loose coupling and helps manage the flow of requests through your
software.

EXAMPLE: GUI
Sure, let's consider a real-world example of the Chain of Responsibility pattern in software development: event
handling in graphical user interfaces (GUIs).

Imagine you're building a graphical user interface for a computer program, and this GUI has various interactive
elements like buttons, text fields, and checkboxes. When a user interacts with the GUI, such as clicking a button, the
system needs to respond appropriately.

In this scenario:
 1. Event Source: The user interacts with a GUI component, like clicking a button.
2. Event Object: An event object is generated, describing the user's action (e.g., a "Button Clicked" event).
3. Handlers in a Chain: Now, you have different objects or components in your GUI, like buttons, text fields,
and checkboxes. Each of these components can have an associated event handler.
4. Chain of Responsibility: When an event occurs, it is passed along a chain of these event handlers. The first
handler in the chain examines the event and decides if it should handle it. If it can handle the event (e.g., the
button's click event handler), it processes it and doesn't pass it along the chain. If it can't handle it (e.g., a
text field can't handle a button click), it passes the event to the next handler in the chain.

This way, you don't need to explicitly code which component should respond to which event in a centralized
manner. Each component knows how to handle its events, and if it can't, it passes them along to the
appropriate handler in the chain. This makes your GUI code more flexible and scalable because you can easily
add or remove components and handlers without having to modify the core event handling mechanism. It
also promotes the principle of single responsibility, as each component is responsible for handling its own
events.

Structural patterns
Decorator
 Primer paso:

 Segundo paso:


Tercer paso: Crear nuestro patrón decorador:

 Cuarto paso: Crear los decoradores que tenga que crear: Un método Crear a
otro método Crear (el de su padre) luego el de él.

 Quinto paso: Producimos el envoltorio de las clases: Es algo así como una
cadena de llamadas

 UML’s Diagram:
Adapter
* Crea una clase que permite q clases con la misma y disitnta implementacion, funcionen
coherentemente
* Analogia-->Apatador frances vs adapatador colombiano.Se compa un adapatador. Entonces,
clase intermedia
* hace q multiples clases con distitnos metodos puede trabajar coherentemente.
* Usado en Legacy Coding.
* vamos a adapatar algo q no cumple con la interfaz a algo que si la cumple. Ejemplo: La clase
ligthub funcion igual
* que mi clase "Lampara".
* Usos-->Trabajar librerias nuevas a librerias viejas. CLAVE-->Adaptar unas funcones
aotras
* Un adapatador para cada cosa que quiera adaptar

 Crear la interfaz con la que estaremos trabajando:

 Diferentes implementaciones de dicha interfaz:

 Nos llega una Legacy Class que tiene conceptos similares pero tenemos que
adaptar:
  Adaptar la Legacy class por una que se adapte a nuestros métodos o
necesidades:

Facade
Un envoltorio q simplifca alto complejo por detrás.
Esconder toda la logica en una llamada. Eso es una fachada. Ocultar la complejidad detrás de un codigo
sencillo.
Creamos una clase tipo fachada, y escondemos la complejidad de todo lo que hay por debajo.
Bridge
The Behavioral Design Pattern called the "Bridge" is like a way to separate an object's abstract structure from its
implementation. Let me explain this in a simple way:

Imagine you have a remote control for your TV. The remote control is like the "Abstraction," and the TV itself is the
"Implementation." Now, let's say you want to change your TV to a different brand or type, like switching from a
Samsung to an LG TV. You don't want to change the whole remote control, just because you changed the TV.

So, the "Bridge" pattern helps you do that. It separates the remote control (Abstraction) from the TV
(Implementation). When you want to use a different TV (Implementation), you don't need to change the remote
control (Abstraction) - you just "bridge" the two by connecting them in a flexible way.

This way, you can use different types of TVs with the same remote control without modifying the remote itself. It's
like having a bridge between different types of TVs and your remote control, allowing them to work together
without being tightly coupled.

In programming, this pattern is used to separate an abstraction (interface or abstract class) from its concrete
implementations. It makes your code more flexible because you can change the implementation without affecting
the abstraction, just like changing your TV without changing the remote control.
Interview’s Questions
1. JRE vs JDK
* JRE es el Java Runtime Environment y es el ambiente de ejecución de java que contiene la
JVM para ejecutar java en cualquier maquina.
* JDK es el Java Development Kit es el conjunto de herramientas para compilar y desarrollar
Java. Contiene las bibliotecas, compilador, etc.
2. Que versión de Java es la ultima?
La versión 20.
3. Que versión de Java usastes, que proyecto?
* Usé la versión 19 y he realizado una API REST para el manejo de citas de laboratorios usando
el Spring Framework la extensión springboot para no tener que configurar manualmente los
beans y por el servidor apache tomcat embebido.
* También participé en el desarrollo de una PoC en la que también usamos la tecnología
SpringBoot y realice unas funciones lambda que las desplegé en aws mediante el servicio
Lambda de AWS. También configuré la conexión con la bases de datos NoSQL en DynamoDB.
* He realizado un sistema para administración de estudiantes.
* Varios ejercicios de API REST.
* Usé JPA, Hibernate
4. ¿Qué es JPA y Hibernate?
* JPA  Java Persistence API, es la API de java o conjunto de interfaces en donde
especificación (Es una especificacón) de como debe realizarse la persistencia de los datos en
cualquier base de datos.
* Hibernate  Es una ORM (Object-Relational Modeling - herramienta que permite relacionar
los objetos de un lenguaje de POO a las entidades o tablas de las bbdd. Una de estas famosas
herramientas es Hibernate, q es la implementación del JPA de java.
Uso realmente no lo hago con las clases de Hibernate creado en entityManager, sino q uso una
capa mas abstracta q es la q proporiciona JpaRepository q usa una capa de abstracción para q
sea más facil (ya viene con un CRUD por defecto).
 Querys
 Querys con JPQL y Nativas.

5. ¿Qué es la programación funcional VS Imperativa con Java?

* La funcional es aquella que se basa en funciones que reciben otras funciones y no solo en
ordenes como la Imperativa. Llamado de funciones y no en el codigo secuencial…
 * Funciones lambdas. Streams.
Funciones puras 1. Dice lo q va a hacer. 2. Siempre devuelve el mismo resultado 3. No afecta
variables globales.
6. ¿ Cuales son las caracteristicas de la POO?
* Polimorfismo: Partiendo de la epistemología, “Poli” significa muchas y “morfismo” formas,
entonces es las distintas formas de respuesta que puede tener una misma entidad. Por
ejemplo, tenemos la clase Carro y esta tiene un atributo abstracto de num_puertas, entonces,
en un carro de carreras (que sería una forma de Carro) tiene un num_puertas distinto a por
ejemplo un carro de ciudad.
* En java, se puede relacionar con clases abstractas, en donde estas no pueden ser
instancias. Pero, aquí entra un tema en discusión que es ¿interfaces o clases abstractas?. Rpta/
Depende para que lo quieras. Si quieras unas subclases que se relacionan entre ellas, clases
abstractas estaría bien, pero si quieres algo mas “contractual” que cumpla y ya, interfaces. La
importancia de esto en Java, es q como es fuertemente tipado, no podes guardar un coche
deportivo, otro de ciudad, etc.
* Herencia: entidades hijas heredan atributos y metodos de entidades padres. El ejemplo más
clasico es el del poligono que este tiene metodos como calcular area y calcular perimetro y ya
cada tipo de poligono implementa.
* Encapsulamiento: Existen, por buenas practicas y por seguirdad, distintos tipos de
modificadores de acceso: privado (solo en la misma clase) publico (en cualquier clase del
proyecto), protected (solo clase y clase que herede) y default (or package).
* Abstracción: Es la capacidad de obtener la informacion de una entidad (infor minima de esa
entidad) y representarle mediante Clases y Objetos.
7. ¿ Refactorizastes alguna vez algun codigo?
* Si, recuerdo que habia que llenar segun unas condiciones que siempre eran las mismas, 2
campos, entonces lo que hie fue en vez de llamar 2 veces a las mismas condiciones, las
organize en una tabla de hash ( en un HashMap) en donde la busqueda de estas condiciones
tiene un coste de 1 o de log(n) tod depende de la función hash.
8. ¿De que forma harías un deploy?
* Primero buscaría la pcion mas economica de algun Cloud Service Platform (AWS Cloud, GCP,
Azure).
* Luego usaría terraform que aunque no se, lo usaría para hacer despliegue de Infraesctructe
As Code (ya realice dicho despleigue pero usando Serverless framework en donde configuraba
el .yml y generaba el .JAR o desplegable).
9. ¿Que herramienta usarías para probar una API REST creada con
Springboot?
* Postman.
10. Diferencia entre Interfaces vs Clases abstractas.
* Puede exisitr una clase que implementa varias interfaces pero no varias clases abstractas,
entonces allí da como ese flexibilidad.
* Los metodos de las interfaces son siempre publicos mientras que en las clases abstractas no
necesariamente.
* Las clases abstractas se usan cuando se quiere hacer uso del polimorfismo o tener diferentes
subclases de un tipo.
* Usaría las interfaces para cuando quisiera tener una serie de contrato a cumplir. Me explico,
si por ejemplo tienes un programa que requiere ciertos metodos y que estos cumplan con su
fuincion podrias crear una cap de servicio q contenga esa logica y una capa de implementación
del servicio que contenga el desarrollo de estas.
* En una clase abstracta puede tener atributos o metodos q no sean abstractos. A diferencia de
la interfaz se tiene q implementar.
11. ¿ Diferencia entre Spring y SpringBoot?
* Spring es el framework, es el core de springboot que es una extensión de este framework y
se usa para la construccion y despliegue rapida de APIs. Ya que en Spring tu tienes que
configurar los beans (objetos de java administrados por el contenedor de objetos de spring q
se encuentran en el application context, muy uito porque vos no tenes q crear 10000 objetos
para 10000 clases, simpolemente le idnicas a spirng q eso es un bean y ya te lo crea, lo
almacena y te lo inyecta)
- En springboot, mediante ciertas anotaciones no es necesario crear los beans. Hay q tener
mucho cuidado y dejar en cada entidad q será un bean un cosntructor vacío y tener en cuenta
las jerarquizacion de los paquetes.
12. Control de versiones GIT
GIT es un sistema de control de versiones que sirve para tener un versionamiento de nuestro
codigo, tener distintas ramas de desarrollo, etc. Existen repositorios locales y globales y un
servicio q te permite tener repos globales es github, gitflow, azue repositories, etc.

13. Principios SOLID

- Para hacer software escalable, mantenible(facil de aplicar cambios).
 Single Responsbility  Principio de responsabilidad única. Una clase o
metodo pora hacer una sola tarea. Ejemplo: no podrá hacer la conexión a la
bbdd, las sentencias SQL o PLSQL. Cada componente debe tener una única
razón para cambiar.

 Open-Closed Abierto y cerrado. El programa tiene que estar abierto a

extensiones pero cerrado a cambios que hagamos en el codigo. En lugar de
modificar el codigo existente, se deben agregar nuevas funcionalidades
mediatnte extension de clases o interfaces. Promueve un diseño más modular
y evitar joder lo q ya esta funcionando. Ejemplo: Tenemos una clase
rectangulo y otra para calcular un area, si quieremos calcular el area del
triangulo, tendríamos que modificar dicha clase AreaCalculator.
 Nota Piensa en interfaces, en clases abstractas, etc.

 Liskov SubstitutionEstablece que los objetos de una clase derivada

deben poder ser usados como substitutos de objetos de clase base, sin
alterar la corrección del programa. cualquier instancia de la clase
derivada debe poder ser tratada como si fuera una instancia de la clase
base, sin causar comportamientos inesperados o errores. Un ejemplo
comúnmente citado es el principio aplicado a las figuras geométricas.
Imagina que tienes una clase base llamada "Figura" con un método
para calcular el área. Luego, tienes una clase derivada llamada
"Cuadrado" que hereda de "Figura" y tiene su propio método para
calcular el área.
Si el principio de Liskov Substitution se cumple, podrías tratar un objeto
"Cuadrado" como un objeto "Figura" en cualquier parte del código sin
problemas.

Toda clase q es hija de otra clase, debe de usarse como si fuera el mismo
padre. No puede comportarse de manera diferente de sus desendientes.
Ejemplo: Tenemos una super clase llamada Duck y queremos un pato de goma DockerDuck .
Este hijo tiene todo lo que hace un Duck pero no Fly() . Aquí estaríamos violando este principio
puesto que la clase hija no se estaría comportando como la clase padre.
Solución  Rediseñar el sistema con componentes individuales o interfaces.
 Interface segregation Estableces que los clientes no deben de depender de
interfaces que no usan. En lugar de tener interfaces monoliticas y genéricas,
se deben dividir en itnerfaz mas peuqeñas para q el cliente use solo lo que
necesita. Reduce dependencias innecesarias y reduce el acoplamiento entre
componentes.

Cherox Creo y desarrollo una Impresora. Grapar hojas y enviar fax. El

software estaba creado por ellos. A medida q iban agregando utilidades,
cualquier cambio por pequeño q fuera era mas complicado de introducir y las
compilaciones eran lentas. Habia una clase Job incorporaba logica de
grapado, impresión, fax. Tenia componentes q usaba muy poca. La sln,
segregar las interfaces q especializabas job. No usaba Job (clase privada)
sino q usaba sus interfaces (Que eran publicas).
NotaTener muchas clases pequeñas y especificas.

 Dependency Inversion Principle 

Establece que los módulos de alto nivel no
deben depender de los módulos de bajo
nivel. Ambos deben de depender de
abstracciones (interfaces o clases
abstractas). Ejemplo: módulo de alto nivel
llamado GestorDePagos que procesa
pagos, en lugar que esta depende de
clases de bajo nivel como PayPal o Stripe
, se deberia de definir una interfaz llamada
ProveedorDePagos que contenga
metodos genericos para procesas pagos.
Luego, las clases concretas "Paypal" y
"Stripe" implementarían esa interfaz. De
esta manera, el módulo "GestorDePagos"
depende de la abstracción (la interfaz) en
lugar de depender directamente de las
clases concretas.
 Nota Reducir el desacople del sistema. No depender de una bbdd de una
tecnologia u otra, sino q nuestro sistema depende de una abstracción que
hemos construido entremedio. La comunicación entre los componentes de
sistema es mediante interfaces y tener libertad que implementación concreta
de cada elemento.

14. Que SGBD utilizaste? Que conexiones hiciste?

* MySQL y usé la interfaz de MySQL workbench para tener como una GUI o algo mas grafico.
No usé MySQL serve sino q usea el servicio RDS en donde configuro la instancia y sobre esa
instancia EC2, configuro mi SGBD y ya creé mi base de datos.
* Con respecto a las conexiones, no las hago de manera manual, es decir no usó que el jdbc y
despues uso el ojdbc del SGDB como oracle 16 y que almaceno los resultados en una clase
llamada ResultSet, sino que usó una ORM como Hibernate para ese mapeo y la conexión me la
rezlia directamente Spring.

15. Sabes hacer consultas, subconsultas, relaciones entre tablas?

* Dependiendo de lo que quiera hacer, modificar, actualizar, borrar, etc. Aunque uso Hibernate
y no es recomendable hacer consultas con querys nativos. Y relaciones entre tablas lo que es
ManyToOne (muchas citas puede tener un paciente pero una cita no puede tener varios
pacientes) y OnetoMany, también el concepto de LazyLoad.

16. Que diferencia existe entre DER y Diagrama de clases (UML)?

* UML  Dentro de UML hay un conjunto de diagramas (Diagramas de secuencia, de
estados,etc). Existen muchos tipos de UML.
* DER 
17. Metodologías agiles
* SCRUM 
* Donde existe un product backlog donde es una lista de las tareas, componentes por
optimizar y demás y estan distribuidas según las historias de usuarios.
* Historias de usuario  “que quiero yo como sistema hacer X cosa” donde estan los
requerimientos, ejemplos, etc.
* Los sprints que por lo general van de 1 semana y especifican el tiempo y a quien, la
prioridad, tiempo restante, comentarios etc de las tareas a realizar.
 * Dailys  Que eran reuniones cortas.
* El scrum master y el product Owner(realcion directa con el cliente), el equipo de
desarrollo (que tiene un lider tecnico).
* Skate holders(relacionados con los sponsors) y usuarios finales.
18. Tips
 Extenderse en las respuestas.
 Si no se, decir que investigo y lo saco.
 Hacer preguntas: Que tecnologías manejaré, como esta conformado el
equipo.
19. Final en java
a. Final en variable es una variable que no se puede modificar.
b. Final en un metodo es q no se va a poder sobreescribir.
c. Final en una clase es q no se puede extender.
20. Cuando tenemos q sobreescribir un metodo?
1. Porque necesitamos metodo q esta abstracto y lo queremos usar.
2. cuando queremos sobreescribirle.
21. Que es una excepcion?
1. medios para manejar situaciones q no son normales. Tendriamos q manegar todas las
situaciones y no que se vaya a romper.
IOException
RunTimeException
22. Que tipo de herencia maneja Java?
1. Herencia simple. Pero usando interfaces puede aplicar herencia multiple NO es asi.
23. Java es compilado e interpretado?
1. Ambos. Compilado pero al q final se ejecuta era la JVM porque interpretaba el archivo
compilado Multiplataforma. Pasa a ser compilado a interpretado y ya a cualquier
Plataforma.

 Java bytecode (.class) JVM interpreta bytecodeGenera el archivo

binario. JVM(Para cada tipo de maquina).
 C++ CompiladorArchivo ejecutable (lenguaje q la computadora
entiende—binario).
 PythonInterprete (linea por linea y traducir el codigo linea x linea en
binario, no se guarda, debe de volver a ejecutarse x la CPU)Ejecutar
nuestro codigo sin pasar por compilación.
Nota: Imaginate una conversiación, con y sin un interprete.
24. Que es .this?
Hacer referencia a un objeto dentro de una clase. Es un contexto, es aquí donde quiero
trabajar.
25. Una superclase de java?
La superclase Object. Ya se esta haciendo una herencia implicita, hay unos metodos ya
definidos pero tu no los hicistes.
26. Java SE(Standar Edition) o Java EE (Entreprise Edition)
Que es lo q quieres hacer en el proyecto? Para ver que APIs necesito, que elementos se
contienen en Estándar Edition. Ej: graficas? Java SE que contiene graficas con Java FX.
27. ¿Por qué generar un constructor vacío?
Obligado a siempre pasarle los parámetros. No obstante, hay situaciones donde no querrán
meter dichos parámetros. Ponerlo siempre q usemos constructores frameworks como spring o
para persistencia como Hibernate porque ellos si lo van a usar. Otro ejemplo útil sería en un
Formulario se crea el objeto vacío y luego se van llenando con los setters. O se ha inciializado
la sesión y necesitas poco a poco ir ingresándole toda la infor del usuario y los necesitas
persistir en la base de datos.

Software Arquitectures

1. Arquitectura Monolítica:
Todo se desplega y desarrolla en una sola unidad ( interfaz, logica empresarial y capa de
acceso de datos estan interconectados y se ejecutan en el mismo proceso. Util en:
Pequeñas aplicaciones internas o prototipos rápidos donde la escalabilidad no
es una preocupación principal.
Aplicaciones simples con una lógica empresarial limitada y pocos componentes.
Escenarios donde se requiere un despliegue sencillo y se gestionan todas las
partes de la aplicación en conjunto.
2. Arquitectura de Cliente-Servidor:
La app se divide en 2 componentes: Cliente y servidor, en donde el cliente es el responsble
de realizar la interfaz y el sevidor manejea la logica empresarial y gestión de datos.
Comunicación através de la red para solicitar y recibir información.
Util en:
Apps que requieren a una base de datos centralizada.

3. Arquitectura de Servicios web SOAP:

Es un protocolo de comunicación basado en XML que permite la comunicación entre sistemas
en la web. Útil en:
Integración de sistemas empresariales donde se requiere comunicación entre
apps.
5. Arquitectura REST:
Se basa en el uso de los protocolos y principios básicos de la web. Los servicios se modelan
como recursos que se acceden mediante URIs y se manipulan a través de operaciones HTTP.
 Aplicaciones web que necesitan de una API simple y fácil de consumir.
Escalabilidad, rendimiento y la interoperabilidad improtantes.

4. Arquitectura orientada a servicios (SOA):

Apps se componene de servicios independientes y autonomos que se comunican entre sí
mediante estandares abiertos como SOAP o REST. Los servicios son unidades lógicas que se
pueden reutilizar y combinar. Util en:
Se requieren reutilización de servicios y composición de aplicaciones a partir de
servicios existentes.
Apps escalables, actualizables y fáciles de mantener.
6. Arquitectura de Microservicios:
Una aplicación se divide en conjunto de servicios pequeños e indepdientes, que se comuncan
através de HTTP o eventos.
Apps complejas y escalables compuesta de servicios multiples.
Mayor flexibilidad, escalabidad de apps.
Usos
Arquitectura Monolítica:
 Una aplicación de procesamiento de pagos que consta de un único componente
de aplicación que maneja todas las funciones de pago, desde la recepción de
solicitudes hasta la validación y el procesamiento de pagos.
Arquitectura de Cliente-Servidor:
 Un sistema de reservas de hoteles donde la interfaz de usuario (cliente) permite
a los usuarios buscar y reservar habitaciones, mientras que la lógica de negocio
y el almacenamiento de datos se encuentran en el servidor.
Arquitectura de Servicios web SOAP:
 Integración de sistemas en una empresa donde diferentes aplicaciones y
servicios se comunican utilizando servicios web basados en SOAP para
intercambiar datos y ejecutar operaciones complejas de manera segura.
Arquitectura REST:
 Un servicio de redes sociales donde los usuarios pueden publicar
actualizaciones, compartir contenido y seguir a otros usuarios. Los datos se
acceden a través de una API REST utilizando solicitudes HTTP como GET,
POST, PUT y DELETE.
Arquitectura orientada a servicios (SOA):
  Un sistema de gestión de inventario de una tienda en línea que se compone de
diferentes servicios independientes, como el servicio de gestión de productos, el
servicio de gestión de pedidos y el servicio de gestión de clientes, que se
comunican entre sí para proporcionar una funcionalidad completa.
Arquitectura de Microservicios:
 Una aplicación de comercio electrónico que se divide en microservicios
independientes, como el servicio de catálogo de productos, el servicio de gestión
de inventario, el servicio de procesamiento de pagos y el servicio de envío, cada
uno de los cuales se puede escalar y desplegar de forma independiente.

Tipos de API

API REST (Representational State Transfer):

Es un estilo de arquitectura de software que utiliza los principios y protocolos de la web para
crear APIs. Las APIs REST se basan en el protocolo HTTP y permiten la interacción con recursos
a través de las operaciones estándar de HTTP, como GET, POST, PUT y DELETE. Utilizan URIs
(Identificadores Uniformes de Recursos) para identificar y acceder a los recursos, y
generalmente transmiten los datos en formatos como JSON o XML.

API WebSocket:
WebSocket es un protocolo de comunicación bidireccional que permite la comunicación en
tiempo real entre un cliente y un servidor. Las APIs WebSocket permiten establecer una
conexión persistente entre el cliente y el servidor, lo que permite una comunicación eficiente y
de baja latencia. Esta API es especialmente útil para aplicaciones en tiempo real, como chats,
juegos en línea, actualizaciones en tiempo real y colaboración en tiempo real.

API GraphQL:
GraphQL es un lenguaje de consulta y manipulación de datos que permite a los clientes
solicitar y recibir solo los datos que necesitan. En lugar de recibir respuestas predefinidas, los
clientes pueden especificar los campos y la estructura de los datos que desean recibir. Las APIs
GraphQL proporcionan una capa de abstracción sobre los servicios y bases de datos
subyacentes, lo que permite una mayor flexibilidad y eficiencia en la recuperación de datos.
API SOAP (Simple Object Access Protocol):
SOAP es un protocolo de comunicación basado en XML que permite la comunicación entre
sistemas distribuidos. Las APIs SOAP definen una estructura y un formato estándar para el
intercambio de mensajes entre el cliente y el servidor. Utilizan el protocolo HTTP o protocolos
específicos como el Protocolo de Transferencia Simple (SMTP) para el transporte de los
mensajes SOAP.

API de servicios web:

Las APIs de servicios web proporcionan una interfaz para interactuar con servicios web que
exponen funcionalidades específicas. Pueden basarse en protocolos como SOAP o REST, y
suelen utilizar descripciones de servicios en lenguajes como WSDL (Web Services Description
Language) o OpenAPI/Swagger para definir la estructura y los métodos disponibles.
1. Entonces, lo que hace Springboot cuando creamos los controladores, y eso.
¿estamos haciendo una API REST implementando la arquitectura REST o de
microservicios?
Cuando creamos controladores en Spring Boot, estamos desarrollando una API REST. Spring
Boot es un marco de trabajo que facilita la creación de aplicaciones Java basadas en Spring,
incluidas las API REST.
En el contexto de Spring Boot, cuando creamos controladores, los mapeamos a ciertas URIs y
asociamos métodos HTTP a esas URIs para realizar operaciones en los recursos
correspondientes. Por ejemplo, si tenemos una entidad "Usuario", podríamos crear un
controlador que responda a solicitudes HTTP para obtener información de usuarios (GET),
crear nuevos usuarios (POST), actualizar usuarios existentes (PUT), eliminar usuarios (DELETE),
etc.
Por otro lado, cuando hablamos de microservicios, nos referimos a un enfoque arquitectónico
en el cual una aplicación se divide en pequeños servicios independientes y desacoplados, cada
uno responsable de una funcionalidad específica. Estos microservicios pueden ser
implementados como API REST, ya que cada uno de ellos puede exponer una interfaz que
permite la comunicación con el servicio.
Si dividimos nuestra aplicación en microservicios independientes, cada uno de ellos podría ser
una API REST que implemente una parte específica de la funcionalidad del sistema.
2. No entiendo muy bien la diferencia entre la arquitectura orientada a
servicios y la arquitectura de microservicios, ademas de la arquitectura REST?
La arquitectura orientada a servicios, la arquitectura de microservicios y la arquitectura
REST son enfoques arquitectónicos diferentes que se utilizan en el desarrollo de
aplicaciones distribuidas. A continuación, te explicaré brevemente cada uno de ellos y
sus diferencias:

2. Arquitectura Orientada a Servicios:

 En la arquitectura orientada a servicios, las aplicaciones se dividen en
servicios independientes que se comunican entre sí a través de interfaces
bien definidas.
 Cada servicio es una unidad lógica de funcionalidad y puede tener su
propia base de código, su propia base de datos y su propio ciclo de vida.
 La comunicación entre los servicios se realiza generalmente a través de
protocolos de comunicación como SOAP (Simple Object Access Protocol) o
REST (Representational State Transfer).
 Esta arquitectura se centra en la reutilización de servicios y la
interoperabilidad entre sistemas.
 Los servicios suelen estar más acoplados entre sí en comparación con la
arquitectura de microservicios.
3. Arquitectura de Microservicios:
 En la arquitectura de microservicios, las aplicaciones se descomponen en
servicios pequeños e independientes, llamados microservicios, que se
ejecutan en su propio proceso y se comunican a través de mecanismos
ligeros como HTTP/REST o mensajería.
 Cada microservicio se enfoca en una única funcionalidad de negocio y se
puede desarrollar, implementar y escalar de forma independiente.
 Los microservicios son autónomos y pueden ser implementados en
diferentes lenguajes de programación o tecnologías, según las necesidades
de cada uno.
 Esta arquitectura fomenta la flexibilidad, el desacoplamiento, la
escalabilidad y la facilidad de mantenimiento de las aplicaciones.
 Los microservicios se comunican a través de interfaces de API bien
definidas y pueden ser implementados utilizando diferentes tecnologías,
incluyendo REST.
4. Arquitectura REST:
 REST es un estilo de arquitectura que se utiliza para diseñar servicios web y
sistemas distribuidos.
  Se basa en un conjunto de principios y restricciones que permiten una
comunicación eficiente y escalable entre componentes distribuidos.
 REST utiliza el protocolo HTTP como capa de transporte y se basa en
conceptos como recursos (identificados por URIs), métodos HTTP (GET,
POST, PUT, DELETE) y representaciones de recursos (generalmente en
formatos como JSON o XML).
 Los servicios RESTful implementan los principios y restricciones de REST, lo
que implica que siguen un enfoque uniforme y centrado en los recursos
para la comunicación.
 REST no implica necesariamente la arquitectura de microservicios, ya que
puede ser utilizado en diferentes tipos de arquitecturas, incluyendo la
arquitectura orientada a servicios.

En resumen, la arquitectura orientada a servicios se centra en la reutilización de

servicios y la interoperabilidad entre sistemas, mientras que la arquitectura de
microservicios se basa en la descomposición de aplicaciones en servicios
independientes y autónomos. Ambas pueden utilizar REST como estilo de
comunicación. REST, por otro lado, es un estilo arquitectónico basado en principios y
restricciones para diseñar servicios web y sistemas distribuidos, y puede ser utilizado en
diferentes arquitecturas, incluyendo la arquitectura orientada a servicios y la
arquitectura de microservicios.

Recursion
Una función se llame a si misma un número de veces.
TIENE que haber una condición para que sea acabe la iteración.
For vs recursividad?—Es según el caso.

Events and GUI

Eventoalgo que se produce. Se divide en (emisor y receptor).
Eventos en la interfaz de usuarioLo que visualmente estamos interactuando.
Swing.>Interfaz para crear la interfaz de usuario.
Todas las apps existentes son de tipo evento.
Ejemplos: seleccionar algo, abrir, cerrar, Lo que ocurre cuando interactúo con la
app.
EventHandlerEvento que se dispara cuando se produce el evento.
Un evento es algo que ocurre cuando algo pasa. Dichas cosas pueden pasar en
cualquier parte modifificable.
Input and output files
ReadAllBytesLee todo pero consume mucho.
ReadLeer carácter por carácter es poco eficiente en términos de recursos.

 Esta la opción de leer en trozos:

Diferencias entre InputStream y BufferStream

InputStream es una clase abstracta public abstract class InputStream con un método read() previsto para leer
un byte de a cada vez desde un fichero

BufferedInputStream no es abstracta, es una clase concreta, por tanto puedes crear instancias de esta clase. Su
método read devuelve un byte de a cada vez pero mantiene un buffer donde va acumulando los bytes
internamente.

La clave en las clases que comienzan con Buffered es que usan un buffer, digamos que una memoria interna
que normalmente hace que esas clases sean más eficientes, es decir, es esperable que BufferedInputStream sea
más rápida que las otras implementaciones de InputStream. La idea sería: un InputStream normal tiene que
estar llamando y accediendo al sistema operativo para cada byte que quiera devolver y esto consume cpu y es
ineficiente. En cambio un BufferedInputStream llama al sistema operativo una vez y recolecta un array de
bytes. Cuando se le pide read() ya no tiene que acceder al sistema operativo, sino que devuelve la información
de su buffer interno. En algún momento el buffer interno se agota, pero mientras esto ocurre se han ahorrado
un montón de procesos.
En conclusión:

 InputStreamLee en un sitio..
 PrintStreamImprimir en donde sea (pantalla, fichero, etc).

Spring using Java.

Un controlador son los que maneja las petición.

El endpoint que sería la URL.
La parte de controllers es como manejramos las peticiones, que hacemos con esas peticiones.
ControllersSon una clases que le indicamos como va a funcionar.
He mandando una petición, lo ha recibido un controlador, y el controlador me ha devuelto algo.
El backend q lanzemos estará en la IP de nuestra computadora 127.0.0 en el puerto que
digamos (por defecto 8080).

 -backend se corre en uno-múltiple servidores

 frontend se ejecuta en el motor de navegador que usemos. Ejemplo:google chrome.
HTTPse implementa de forma REST(Como se hacen todas las APIS).

Servicios REST
App web q cumple una serie de patrones determinados.
Verbos HTTPTipo de peticion q enviamos al servidor usando el protocolo HTTP.
- GET: Obtiene recurso (imagen, video, html, etc) de un servidor
- POST: Envio datos al servidor (Ejemplo, en un formulario, se envia datos a un servidor).
- PUT: Actualice un usuario TODOS LOS datos del usuario
- PATCH: Cambiaria unicamente los datos que desea actualizar (Muchas no soportan el
PATCH)
- DELETE
- CRUD
GET https://www.dominio.tld/bootcampers
  Bootcampers Recurso
 Usuario 1
 Usiaro 2 usuario 3
POST https://www.dominio.tld/bootcampers
“Por favor crea un nuevo usuaruio con nombre XXXX”
PUT https://www.dominio.tld/bootcampers/Usuario
 Actualizar algun recurso
DELETE https://www.dominio.tld/bootcampers/Usuario1

NOTAS:
1. Los recursos son nombres no verbos:
https://www.dominio.tld/users
https://www.dominio.tld/api/v1/users
-POST “nombre”,”apellidos”
https://www.dominio.tld/api/v2/users
-POST “nombre completo”
* Muy importante para la migración
https://www.dominio.tld/users/parangos
https://www.dominio.tld/users/12
https://www.dominio.tld/users/subjects

https://www.dominio.tld/cats
https://www.dominio.tld/pets
Java web

🔴 ARQUITECTURA CLIENTE SERVIDOR | 🌎 ¿Cómo FUNCIONA LA WEB?

| ✅ PROGRAMACIÓN WEB + HTML + CSS 2022

 Servidor: otra computador q procesa la petición y genera una respuesta. Se

comunican mediante un protocolo HTTP.


Conexión encriptada mediante un certificado SSL.

 -

⭐PROTOCOLO HTTP Requests y Responses con: GET, POST, PUT,

PATCH y DELETE | DESARROLLO WEB 🌎

 El PROTOCOLO HTTP establece la forma en que se debe esta compuesta

una request y una response. Cada request, esta compuesto por un
paquete.
 Metodo verbo sobre q acción pretendemos realizar.
 URL la url donde esta nuestro recurso.
 Header infor importante, ej: un mensaje paricular q quiero
transmitir, en formato json (Como las cookies) o queryParams.
 Body Complementar lo q va en la cabecera,etc.
⭐ ¿Qué
son
las

APIS? ¿Para qué sirven? EJEMPLO PRÁCTICO con la POKEAPI |

DESARROLLO WEB 🌎
 Conjunto de funcones metodos procedimientos. Ej: un app frontend y
backend y comunicarlas entre sí mediante las apis.
 o APIS  endpoint para q el frontend lo consuma.

 Comunicaciones mediante REST (Reprentational State Transfer- Estado

de Transferencia Representacional) las comunicaciones no tienen algun
estado, es decir, toda la informacion se la tengo q pasar a la solicitud.
 No importa la tecnologia de los clientes o servidores, puesto q los mensajes
se envían en formato JSON o XML.
🌎 ¿QUÉ ES JAVA WEB? ¿Qué es JSP (Java Server Pages)?🚀| Curso gratis 2023

JSP  HTML + Java (paginas dinamicas,etc).

Glosario
XAMPP
 Apache convertir computadora en servidor web (servidor local).
 MySQL Servidor de bbdd donde almacenaremos la infor.
Interesante: Para desplegar una app en un servidor apache tomcat (contenedores de servlet)
tenemos q construir una imagen con un SO e instalarlo, luego copiar los archivos de nuestro
ejecutable .JAR y correr un contenedor dentro de la instancia EC2.

Etiquetas

🚀 ¿Qué es un SERVLET en JAVA? | Java WEB Curso gratis 2023 #4 ⭐

1. Usuario realiza formulario JSP (HTML+JAVA)
2. Se envia peticion al servelet. Lo recibe mediante doPost() y da una respuesta.

 Por cada clase, vamos a tener probablemente un servlet. No solo se usa un

servlet sino varios.
 Se puede implemetar la comunicación servlet – JSP de 2 maneras:
1. 1. Un JSP q se comunica con al servelet.
2. 2. Servelt funciona como un JSP (Es decir, q dentro del servelet se muestra
el codigo HTML q queremos q visualize el usuario).
Exercises
Exercism
1. Queen Attack

LeetCode

Remove Duplicates from Sorted Array II

* NotaIndices según mis necesidades.
Remove Duplicate words

169. Majority Element

* No realizar calculos inecesarios si tienes afirmaciones de entrada.
* Investigar acerca de los metodos de la clase Array.

169. Majority Element

189. Rotate Array
* Tecnica de la reversion que es una forma eficiente de rotar un arreglo a la derecha por k
pasos.
Lonely Integer
  Operador XOR:
 Dos números iguales, el resultado es 0.
 Un número y 0, el resultado es el mismo número.
 A elementos de una lista, elimina los duplicados.

diagonalDifference
 RECUERDA siempre encontrar patrones en el comportamiento:

121. Bestime to buy and sell stock

 Aprendizaje: Juega con los indices: es decir, cuestionarse: ¿Qué pasa si este
indice va para allá y este se queda quieto acá pero bajo ciertas condiciones? Es
decir, no todo tiene que ser un solo indice y no siempre es constante su
movimiento.
 Nota: También podrías realizar diagramas de como se está comportando el
diagrama. Por ejemplo, a continuación vemos el diagrama del precio de las
acciones con el pasar del tiempo, en donde podemos ver máximos, mínimos.
  Programming techch  2 pointers: Aquí teniamos 2 variables o pointers que
usaríamos Left (L) Y Right (R) en donde L=DayBuy y R = DaySell. Si encuentro
uno negativo, estamos hablando con el día en que se encontró un precio muy
barato para vender, por tanto, ese día será nuestro L hasta encontrar un máx.

122. Bestime to buy and sell stock II

* Nota  Recuerda nuevamente graficar para ver el comportamiento de las acciones. Cada vez
que haya un nuevo incremento del profit lo sumamos, pero, ¿Cuándo hay un incremento en el
profit? Cuando el valor de venta es mayor al de compra, de lo contrario solo cambiaría el dia
en que se compra que SERÍA: SI EL PRECIO DE VENTA (i) es MAYOR AL DE COMPRA (i-1),
SUMELO SINO SOLO SON PERDIDAS.
HackerRank

Jose’s sure bet

#3 Opciones
1. for i in range(0,len(home_bets)):
2. for j in range(0,len(home_bets)):
3. for k in range(0,len(home_bets)):
4. if(i!=j or j!=k):
5. permutation=[home_bets[i][0],home_bets[j][1],home_bets[k][2]]
6. permutations.append(permutation)
Udemy
 Refactoring code reusing validations methods for the following methods.