La clase inmutable que consideras inmutable creo que no es totalmente, porque si esta bien que haga un copiado de la lista cada vez que se llama el metodo get, cuando el objeto se crea por primera vez el valor de la lista “emails” que envias no le hace ningun copiado, simplemente lo coloca directamente en el atributo emails de la clase, eso hace que el programador a futuro pueda tomar esa lista que le envio al objeto inmutable y modificarla desde afuera, y al modificarla desde afuera, eso modifica el valor de la referencia que tiene en la clase inmutable.
Introducción a la programación Funcional
¿Qué es la Programación Funcional?
Entendiendo las partes de la programación funcional
¿Qué es una función en Java?
Funciones como ciudadanos de primera clase
Funciones puras
Entendiendo los efectos secundarios
Funciones de orden mayor
Funciones lambda
Inmutabilidad
Functional Programming en Java
Repositorio del curso
Configuración del entorno de trabajo
Revisando el paquete java.util.function: Function
Revisando el paquete java.util.function: Predicate
Revisando el paquete java.util.function: Consumer y Supplier
Revisando el paquete java.util.function: Operators y BiFunction
Entendiendo dos jugadores clave: SAM y FunctionalInterface
Operador de Referencia
Analizando la inferencia de tipos
Comprendiendo la sintaxis de las funciones lambda
Usando metodos default en nuestras interfaces
Dándole nombre a un viejo amigo: Chaining
Entendiendo la composición de funciones
Optional y Streams: Datos mas interesantes
La clase Optional
Entendiendo los Streams
¿Qué son los Stream listeners?
Operaciones y Collectors
Streams de tipo específico y Paralelismo
Operaciones Terminales
Operaciones Intermedias
Collectors
Todo junto: Proyecto Job-search
job-search: Un proyecto para encontrar trabajo
Vista rápida a un proyecto de Gradle
Revisando las opciones para nuestro CLI
Librerías adicionales para nuestro proyecto
Entendiendo la API de jobs
Diseñando las Funciones Constructoras de nuestro Proyecto
Agregando validaciones de datos
Diseñando las funciones de transformacion de datos
Creando flujos extras de transformación de Datos
Conclusiones
Un repaso a lo aprendido
No tienes acceso a esta clase
¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera
Si ya tienes una cuenta,
No se trata de lo que quieres comprar, sino de quién quieres ser. Invierte en tu educación con el precio especial
Antes: $249
$209
Paga en 4 cuotas sin intereses
Termina en:
12 Días
12 Hrs
18 Min
13 Seg
Inmutabilidad
8/39Recursos
Aportes 43
Preguntas 5
Ordenar por:
Escuchando lo de concurrente, estaría genial un curso de programación concurrente con Java y sus Threads. Es algo apasionante.
Ser o no ser inmutable, esa es la cuestión.
Para complementar:
final en Java poco tiene que ver con mutabilidad. Marcar como final un nombre (miembro de clase o variable local) hace que dicho nombre sea read-only una vez el mismo es instanciado.
final myVar = new ArrayList<String>();
myVar = Collections.emptyList(); // Incurre en un error porque myVar es de solo lectura (no se puede re-asignar)
Pero nada evita mutar el objeto referenciado por un nombre marcado como final
final myVar = new ArrayList<String>();
myVar.add("Hello");
Para evitar la mutación, además de usar nombres marcados como final, hay que usar tipos de datos inmutables (ArrayList no es uno de ellos), evitar la herencia donde es posible y respetar el principio de sustitución de Liskov cuando no lo es.
Uso de la palabra final en Java
- En variables: Evita que se modifique el valor almacenado de la variable
- En métodos: Evita que se modifique la definicion del metodo desde subclases o clases hijas
- En clases: Evita que se creen subclases o clases hijas
final
Como comenta el compañero Carlos Torres, La clase InmutablePerson no quedó inmutable realmente. Como los LinkedList son objetos, estos se guardan en una dirección de memoria. Lo anterior ocasiona que cuando se pasa la lista de emails en el constructor este se envía como un puntero o referencia a la dirección de memoria del listado. Lo cual implica que si alguien modifica el listado de emails original, el cambio se verá reflejado también en el atributo this.emails del objeto ImmutablePerson ya que este apunta a la misma dirección.
Para corregir esto no sólo se debe crear una copia de los emails en el getEmails sino también en el constructor, por lo tanto el constructor debería quedar así:
<code>
public InmutablePerson(String firsName, String lastName, List<String> emails`){
this.firstName = firstName;
this.lastName = lastName;
this.emails = new LinkedList<>(emails);
}
``
Inmutabilidad
Un objeto inmutable es aquel cuyo estado no se puede cambiar una vez construído.
Ventajas :
-> Una vez creado no se puede alterar.
-> Facilidad para crear funciones puras.
-> Facilidad para usar threads/concurrencia.
Desventajas :
-> Cuando se necesecite alterar un datos, se requiere crear una nueva instancia por cada set modificado.
-> Requiere especial atención al diseño.
-> Los objetos mutables están fuera de nuestro alcance, porque se vuelven inpredecibles
Caray fascinante esta explicación we :v
toma tu like buen hombre
hasta este punto NO entendi casi nad 😦
Excelente clase y capítulo!
Muy claro y conciso todo.
Inmutabilidad
Tanto en la programación orientada a objetos como en la funcional, un objeto inmutable es aquel cuyo estado no puede ser modificado luego de haber sido instanciado.
⠀
Por defecto en Java, los objetos sin mutables, esto significa que luego de tener un objeto en memoria se puede modificar sus atributos utilizando getters y setters, lo que podría alterar el comportamiento del programa si este tipo de objeto se pasa como parámetro a funciones impuras.
⠀
El uso de la inmutabilidad en los objetos conlleva ventajas y desventajas:
⠀
Ventajas:
- No se puede modificar luego de creado.
- Facilita la creación de funciones puras.
- Facilita el uso de hilos evitando problemas deconcurrencia.
⠀
Desventajas:
- Si se quiere modificar, es necesario crear una copia (nueva instancia) del objeto con la modificación deseada.
- Se debe prestar atención en el diseño e implementación para garantizar la inmutabilidad.
- Existen objetos fuera de alcance (nativos o de librerías) que al ser mutables pueden ser inpredecibles.
Jaja, que buenos ejemplos y buen profesor
En Java, para hacer que una clase sea inmutable, debes seguir algunos principios y utilizar ciertas técnicas. Aquí hay algunas recomendaciones para lograrlo:
-
Declarar la clase como final: Al declarar una clase como final, evitas que pueda ser heredada y modificada por clases hijas.
-
Declarar los campos como private y final: Al hacerlo, los campos no podrán ser modificados desde fuera de la clase después de su inicialización. Debes asegurarte de inicializar todos los campos en el constructor o mediante una asignación directa.
-
No proporcionar métodos mutadores (setters): Evita la creación de métodos que permitan cambiar los valores de los campos después de la creación del objeto. Esto garantiza que una vez que se cree un objeto, sus campos permanezcan inmutables.
-
Evitar el retorno de referencias mutables: Si una clase inmutable contiene campos que son objetos mutables, debes tener cuidado al devolver referencias a esos objetos. Si se devuelve una referencia mutable, se podría modificar el estado interno de la clase inmutable. En su lugar, si es necesario devolver un objeto mutable, deberías realizar una copia defensiva del mismo.
-
Hacer que los campos sean primitivos o inmutables: Al utilizar tipos primitivos como int, boolean, etc., o tipos de datos inmutables como String o BigDecimal, aseguras que los valores de los campos no se puedan modificar después de la creación del objeto.
-
Asegurarse de que la clase no pueda ser extendida: Además de declarar la clase como final, también puedes hacer que el constructor de la clase sea privado o protegido, evitando así que se pueda crear subclases.
Siguiendo estas recomendaciones, puedes crear una clase inmutable en Java, lo que garantiza que los objetos de esa clase no se puedan modificar una vez creados. Esto puede ser útil en situaciones donde deseas garantizar la consistencia y la integridad de los objetos.
Excelente clase.
El concepto de mutabilidad es muy útil e interesante.
En lenguajes funcionales esto es mucho más sencillo, pues los datos son inmutables por default y es imposible mutar un dato inmutable.
Realmente en Java no hay tipos inmutables, lo que hay son Wrappers que encapsulan los datos mutables dentro de una implementación de métodos que no modifica nada y que impiden la extensión de funcionalidad.
Es decir, hay implementaciones inmutables más no tipos de datos o variables inmutables como en Rust o lenguajes netamente funcionales.
En mi consideración, esto impacta el rendimiento de java y la cantidad de cosas que tiene que mirar el garbage collector haciéndolo mucho más lento que un lenguaje funcional en el ámbito de la inmutabilidad.
records de java 14 en adelante es una manera muy bella de crear Clases inmutables.
<https://www.baeldung.com/java-record-keyword>
Es la clase mas rompe cocos q he visto wey, q fascinante.
Todo muy claro y sinceramente son cosas que se deben de tener en cuenta mas que todo en datos o informacion importante. Una pregunta: final recuerdo lo he utilizado para crear este tipo de objetos:
public static final String[] MONTHS = {"Enero","Febrero","Marzo","Abril","Mayo","Junio","Julio","Agosto","Septiembre","Octubre","Noviembre","Diciembre"};```
Se utilizo FINAL con la finalidad de indicar que era una constante (pues los meses del año siempre seran 12 y los mismos) y pues que no cambian. En este caso se estaria manejando Inmutabilidad ??? No lo he intentado, pero a pesar de haberlo creado asi, si yo intento en alguna funcion, clase, metodo intentar asignarle o cambiarle algun valor me imagino podria afectar, en ese caso como evito la mutabilidad?? A mi locamente en estos momentos se me ocurre crear alguna variable y guardar esa misma informacion, al momento de necesitar Months colocar una condicion que averigue si siguen siendo iguales.
Gracias.
Gracias 😃
Solo sigo adelante para no dejarle a la frutración ganar, pero no entiendo nadaaa
Gracias por esta clase, de verdad que aprendí bastante, gracias Platzi,
Dios los bendiga
Aqui mi aporte, por si no les quedo muy claro. Por lo que entendí es que la inmutabilidad hace que tu código sea más seguro, más predecible y más fácil de trabajar, especialmente en situaciones donde hay concurrencia o cuando quieres asegurarte de que los datos no cambien accidentalmente.
EJEMPLO:
Imagina que tienes un objeto como una caja que contiene algunos datos. Si esa caja es mutable, significa que puedes abrir la caja y cambiar los datos que contiene en cualquier momento. Por otro lado, si esa caja es inmutable, una vez que la has sellado con esos datos dentro, no puedes abrir la caja para cambiarlos.
```java
// Ejemplo de clase mutable
class MutablePerson {
private String name;
public MutablePerson(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
// Ejemplo de clase inmutable
final class ImmutablePerson {
private final String name;
public ImmutablePerson(String name) {
this.name = name;
}
public String getName() {
return name;
}
// No hay un método setter, lo que hace que esta clase sea inmutable
}
public class Main {
public static void main(String[] args) {
// Crear un objeto mutable
MutablePerson mutable = new MutablePerson("Juan");
System.out.println("Mutable: " + mutable.getName());
// Cambiar el nombre del objeto mutable
mutable.setName("Maria");
System.out.println("Mutable después de cambiar el nombre: " + mutable.getName());
// Crear un objeto inmutable
ImmutablePerson immutable = new ImmutablePerson("Pedro");
System.out.println("Inmutable: " + immutable.getName());
// Intentar cambiar el nombre del objeto inmutable (esto dará un error de compilación)
// immutable.setName("Luis"); // Esto no compilará porque no hay método setName en ImmutablePerson
}
}
```
Aqui mi aporte, pr si no les quedo muy claro.
Por lo que entendí es que la inmutabilidad hace que tu código sea más seguro, más predecible y más fácil de trabajar, especialmente en situaciones donde hay concurrencia o cuando quieres asegurarte de que los datos no cambien accidentalmente.
EJEMPLO:
Imagina que tienes un objeto como una caja que contiene algunos datos. Si esa caja es mutable, significa que puedes abrir la caja y cambiar los datos que contiene en cualquier momento. Por otro lado, si esa caja es inmutable, una vez que la has sellado con esos datos dentro, no puedes abrir la caja para cambiarlos.
```js
// Ejemplo de clase mutable
class MutablePerson {
private String name;
public MutablePerson(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
// Ejemplo de clase inmutable
final class ImmutablePerson {
private final String name;
public ImmutablePerson(String name) {
this.name = name;
}
public String getName() {
return name;
}
// No hay un método setter, lo que hace que esta clase sea inmutable
}
public class Main {
public static void main(String[] args) {
// Crear un objeto mutable
MutablePerson mutable = new MutablePerson("Juan");
System.out.println("Mutable: " + mutable.getName());
// Cambiar el nombre del objeto mutable
mutable.setName("Maria");
System.out.println("Mutable después de cambiar el nombre: " + mutable.getName());
// Crear un objeto inmutable
ImmutablePerson immutable = new ImmutablePerson("Pedro");
System.out.println("Inmutable: " + immutable.getName());
// Intentar cambiar el nombre del objeto inmutable (esto dará un error de compilación)
// immutable.setName("Luis"); // Esto no compilará porque no hay método setName en ImmutablePerson
}
}
```// Ejemplo de clase mutable
class MutablePerson {
private String name;
public MutablePerson(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
// Ejemplo de clase inmutable
final class ImmutablePerson {
private final String name;
public ImmutablePerson(String name) {
this.name = name;
}
public String getName() {
return name;
}
// No hay un método setter, lo que hace que esta clase sea inmutable
}
public class Main {
public static void main(String\[] args) {
// Crear un objeto mutable
MutablePerson mutable = new MutablePerson("Juan");
System.out.println("Mutable: " + mutable.getName());
// Cambiar el nombre del objeto mutable
mutable.setName("Maria");
System.out.println("Mutable después de cambiar el nombre: " + mutable.getName());
// Crear un objeto inmutable
ImmutablePerson immutable = new ImmutablePerson("Pedro");
System.out.println("Inmutable: " + immutable.getName());
// Intentar cambiar el nombre del objeto inmutable (esto dará un error de compilación)
// immutable.setName("Luis"); // Esto no compilará porque no hay método setName en ImmutablePerson
}
}
This is the same result using Java records.
```js
package study.java;
import java.util.LinkedList;
import java.util.List;
public record Person(String name, String lastname, List<String> emails) {
@Override
public List<String> emails() {
return new LinkedList<>(emails);
}
}
```package *study.java*;
import *java.util.LinkedList*;
import *java.util.List*;
public record *Person*(*String* name, *String* lastname, *List*<*String*> emails) {
*@Override*
** public *List*<*String*> *emails*() {
return new *LinkedList*<>(emails);
}
}
Hola, cuando dices que una función que no genere efectos secundarios es mas fácil de meter en diferentes procesadores, te refieres a que es mas facil de meter en diferentes núcleos? Gracias
“Plain Old Java Object” (Objeto Java Sencillo y Antiguo)
.
- Los POJOs son clases simples que encapsulan datos y tienen métodos para acceder y manipular esos datos.
Esta clase la tuve que ver dos veces después de bajar el proyecto. Pero me quedo muchísimo más claro el concepto y es algo que jamás me había puesto a pensar en mis desarrollos: la mutabilidad e inmutabilidad. El ejercicio de realizar copias de los datos y regresar esas copias es bestial y me iluminó para muchas soluciones en mis desarrollos.
Siento que hizo falta explicar la diferencia entre tipos de datos primitivos y los de tipo referencia, yo solo entendi gracias a que ya sabía ese tema.
Inmutabilidad
- Ventajas de datos inmutables
- Una vez creado no se puede alterar.
- Facilita crear funciones puras.
- Facilita usar threads/concurrencia.
- Desventajas
- Nueva instancia por cada set de modificaciones.
- Requiere especial atención al diseño.
- Objetos mutables fuera de nuestro alcance, no tenemos acceso a ellos.
Excelente clase, cambio mi manera de pensar sobre crear objetos mutables, me gustaría que realizaran un curso sobre la protección de datos en java y la inmutabilidad.
Excelente capitulo, hay mucho que aprender
Excelente!
Quiza me perdie pero prefiero preguntar que quedarme con la duda, entiendo entonces que para dicha clase en java debemos colocar la clase como final. Asi deberia ser cuando estemos programando ? Tengo esa duda.
Excelente clase instructor Sinuhé, no conocía esa vulnerabilidad que tenía la creación de objetos mutables respecto a la manipulación de datos.
En cuanto a la clase que se creó para generar objetos inmutables se utilizó la palabra final tanto en la clase como los atributos o propiedades para evitar lo modificación, el método que exige todas las propiedades y por ultimo permitió que se generara una copia de la lista de correos.
Muchas gracias por la clase instructor Sinuhé.
Buena clase
Genial 😃
Excelente, muy bueno.
Tenia entendido que con declarar los métodos privados y utilizar los getters y setters nos protegíamos de alteraciones a los parámetros del código pero esto no me lo esperaba, es algo nuevo saber que una función de librería pueda alterar los valores finales de código así.
Esta clase llamo mi atención, seguimos adelante. Gracias !
Increíble como debemos siempre de preocuparnos como pueden alterar el comportamiento de nuestro código. Siempre debemos en la medida de lo posible y cuando se necesite evitar que nuestras funciones sean alteradas bajo este principio, para garantizar la integridad de la información.
Excelente clase!!! 👍🏽
Woow excelente la inmutabilidad primera vez que lo veo
Increible el principio de inmutabilidad
¿Quieres ver más aportes, preguntas y respuestas de la comunidad?