Mutable objects in java

Difference between Mutable objects and Immutable objects [duplicate]

Mutable objects have fields that can be changed, immutable objects have no fields that can be changed after the object is created.

A very simple immutable object is a object without any field. (For example a simple Comparator Implementation).

class Mutable < private int value; public Mutable(int value) < this.value = value; >//getter and setter for value > class Immutable < private final int value; public Immutable(int value) < this.value = value; >//only getter > 

Mutable objects can have their fields changed after construction. Immutable objects cannot.

public class MutableClass < private int value; public MutableClass(int aValue) < value = aValue; >public void setValue(int aValue) < value = aValue; >public getValue() < return value; >> public class ImmutableClass < private final int value; // changed the constructor to say Immutable instead of mutable public ImmutableClass (final int aValue) < //The value is set. Now, and forever. value = aValue; >public final getValue() < return value; >> 

Immutable objects are simply objects whose state (the object’s data) cannot change after construction. Examples of immutable objects from the JDK include String and Integer.

For example:(Point is mutable and string immutable)

 Point myPoint = new Point( 0, 0 ); System.out.println( myPoint ); myPoint.setLocation( 1.0, 0.0 ); System.out.println( myPoint ); String myString = new String( "old String" ); System.out.println( myString ); myString.replaceAll( "old", "new" ); System.out.println( myString ); 

java.awt.Point[0.0, 0.0] java.awt.Point[1.0, 0.0] old String old String 

Источник

Mutable VS Immutable Objects In Java: When To Use Each

Welcome to an engaging exploration of mutable and immutable objects in Java. This guide unpacks the nuances of both, lays out their differences, and offers best practices for their use. Armed with real-life examples, humor, and insight, you’re in for a delightful and enlightening journey.

Have you ever heard about the Java developer who was frustrated with his relationship status? Well, he couldn’t figure out if he was in a ‘mutable‘ or an ‘immutable‘ one!

On a more serious note, if you’re a Java developer, understanding the difference between mutable and immutable objects isn’t just fodder for nerdy jokes — it’s crucial to your coding prowess.

Think of mutable objects as clay in a sculptor’s hands — they can be molded and changed as per the sculptor’s (read: programmer’s) whims. On the other hand, immutable objects are more like a diamond — once formed, they’re forever, unchangeable and steadfast.

Mutable and immutable objects are like the yin and yang of Java. They complement each other and bring balance to the Java universe. By the end of this article, you’ll be able to discern when to use each, navigating the Java waters with an ease that would make a seasoned sailor nod in approval.

So, buckle up for a riveting exploration into the world of mutable and immutable objects in Java. Let’s get this party started, shall we?

Remember, in the world of programming, your code is only as strong as your understanding of the basics. In the wise words of a Java guru, «To code, or not to code, that is the question. But first, do you know your mutable from your immutable?»

Important disclosure: we’re proud affiliates of some tools mentioned in this guide. If you click an affiliate link and subsequently make a purchase, we will earn a small commission at no additional cost to you (you pay nothing extra). For more information, read our affiliate disclosure.

Definitions And Basic Concepts

First things first, let’s get our terminology straight. If you’ve ever been to a costume party, you’ll know that everyone comes as something or someone else, right? Mutable and immutable are just fancy costumes that our dear Java objects like to don. But what do these terms really mean?

In the simplest terms, a mutable object is like a chameleon, always changing its colors. It’s an object whose state can be changed after it’s created. It’s like that versatile Swiss army knife that’s always adapting to your needs.

On the flip side, an immutable object is like Mount Everest — steady and unchanging. Once an immutable object is created, its state remains the same for the rest of its lifetime, much like your DNA (unless you’re a comic book superhero, of course!).

Источник

Иммутабельность в Java

Привет, Хабр. В преддверии скорого старта курса «Подготовка к сертификации Oracle Java Programmer (OCAJP)» подготовили для вас традиционный перевод материала.

Приглашаем также всех желающих поучаствовать в открытом демо-уроке «Конструкторы и блоки инициализации». На этом бесплатном вебинаре мы:
— Разберём конструктор на запчасти
— Определим финалистов (финальные переменные)
— Наведём порядок (инициализации)

Иммутабельный (неизменяемый, immutable) класс — это класс, который после инициализации не может изменить свое состояние. То есть если в коде есть ссылка на экземпляр иммутабельного класса, то любые изменения в нем приводят к созданию нового экземпляра.

Чтобы класс был иммутабельным, он должен соответствовать следующим требованиям:

• Должен быть объявлен как final, чтобы от него нельзя было наследоваться. Иначе дочерние классы могут нарушить иммутабельность.
• Все поля класса должны быть приватными в соответствии с принципами инкапсуляции.
• Для корректного создания экземпляра в нем должны быть параметризованные конструкторы, через которые осуществляется первоначальная инициализация полей класса.
• Для исключения возможности изменения состояния после инстанцирования, в классе не должно быть сеттеров.
• Для полей-коллекций необходимо делать глубокие копии, чтобы гарантировать их неизменность.

Иммутабельность в действии

Начнем со следующего класса, который, на первый взгляд, выглядит иммутабельным:

import java.util.Map; public final class MutableClass < private String field; private MapfieldMap; public MutableClass(String field, Map fieldMap) < this.field = field; this.fieldMap = fieldMap; >public String getField() < return field; >public Map getFieldMap() < return fieldMap; >>

Теперь посмотрим на него в действии.

import java.util.HashMap; import java.util.Map; public class App < public static void main(String[] args) < Mapmap = new HashMap<>(); map.put("key", "value"); // Инициализация нашего "иммутабельного" класса MutableClass mutable = new MutableClass("this is not immutable", map); // Можно легко добавлять элементы в map == изменение состояния mutable.getFieldMap().put("unwanted key", "another value"); mutable.getFieldMap().keySet().forEach(e -> System.out.println(e)); > > // Вывод в консоли unwanted key key

Очевидно, что мы хотим запретить добавление элементов в коллекцию, поскольку это изменение состояния объекта, то есть отсутствие иммутабельности.

import java.util.HashMap; import java.util.Map; public class AlmostMutableClass < private String field; private MapfieldMap; public AlmostMutableClass(String field, Map fieldMap) < this.field = field; this.fieldMap = fieldMap; >public String getField() < return field; >public Map getFieldMap() < MapdeepCopy = new HashMap(); for(String key : fieldMap.keySet()) < deepCopy.put(key, fieldMap.get(key)); >return deepCopy; > >

Здесь мы изменили метод getFieldMap , который теперь возвращает глубокую копию коллекции, ссылка на которую есть в AlmostMutableClass . Получается, что если мы получим Map , вызвав метод getFieldMap , и добавим к нему элемент, то на map из нашего класса это никак не повлияет. Изменится только map , которую мы получили.

Однако если у нас остается доступ к исходной map , которая была передана в качестве параметра конструктору, то все не так уж и хорошо. Мы можем изменить ее, тем самым изменив состояние объекта.

import java.util.HashMap; import java.util.Map; public class App < public static void main(String[] args) < Mapmap = new HashMap<>(); map.put("good key", "value"); // Инициализация нашего "иммутабельного" класса AlmostMutableClass almostMutable = new AlmostMutableClass("this is not immutable", map); // Мы не можем изменять состояние объекта // через добавление элементов в полученную map System.out.println("Result after modifying the map after we get it from the object"); almostMutable.getFieldMap().put("bad key", "another value"); almostMutable.getFieldMap().keySet().forEach(e -> System.out.println(e)); System.out.println("Result of the object's map after modifying the initial map"); map.put("bad key", "another value"); almostMutable.getFieldMap().keySet().forEach(e -> System.out.println(e)); > > // Вывод в консоли Result after modifying the map after we get it from the object good key Result of the object's map after modifying the initial map good key bad key

Мы забыли, что в конструкторе нужно сделать то же самое, что и в методе getFieldMap . В итоге конструктор должен выглядеть так:

public AlmostMutableClass(String field, Map fieldMap) < this.field = field; MapdeepCopy = new HashMap(); for(String key : fieldMap.keySet()) < deepCopy.put(key, fieldMap.get(key)); >this.fieldMap = deepCopy; > // Вывод в консоли Result after modifying the map after we get it from the object good key Result of the object's map after modifying the initial map good key

Хотя использование иммутабельных объектов дает преимущества, но их использование не всегда оправдано. Обычно нам нужно как создавать объекты, так и модифицировать их для отражения изменений, происходящих в системе.

То есть нам нужно изменять данные, и нелогично создавать новые объекты при каждом изменении, так как это увеличивает используемую память, а мы хотим разрабатывать эффективные приложения и оптимально использовать ресурсы системы.

Иммутабельность строк в Java

Класс String , представляющий набор символов, вероятно, самый популярный класс в Java. Его назначение — упростить работу со строками, предоставляя различные методы для их обработки.

Например, в классе String есть методы для получения символов, выделения подстрок, поиска, замены и многие другие. Как и другие классы-обертки в Java (Integer, Boolean и т.д.), класс String является иммутабельным.

Иммутабельность строк дает следующие преимущества:

• Строки потокобезопасны.
• Для строк можно использовать специальную область памяти, называемую «пул строк». Благодаря которой две разные переменные типа String с одинаковым значением будут указывать на одну и ту же область памяти.
• Строки отличный кандидат для ключей в коллекциях, поскольку они не могут быть изменены по ошибке.
• Класс String кэширует хэш-код, что улучшает производительность хеш-коллекций, использующих String .
• Чувствительные данные, такие как имена пользователей и пароли, нельзя изменить по ошибке во время выполнения, даже при передаче ссылок на них между разными методами.

Источник

Что такое mutable/immutable объекты и зачем они

— Сегодня Билаабо расскажет тебе о mutable и immutable объектах.

Объекты, которые после создания можно изменить, называются изменяемыми или mutable.

Объекты, которые после их создания изменить нельзя, называются неизменяемыми или immutable.

— А от чего зависит, можно объект менять или нет?

— Человек, который пишет новый класс, может сделать объекты этого класса неизменяемыми. Например, можно скрыть все setter’ы — у объекта будет только конструктор и getter’ы, а, значит, после создания объекта поменять его уже будет нельзя.

— У неизменяемых объектов много полезных свойств. Но можно выделить два, которые характерны практически для всех immutable-объектов:

1) Неизменяемые объекты можно реализовать значительно проще, чем изменяемые.

2) Неизменяемые объекты можно свободно использовать одновременно из разных нитей.

Чаще всего, когда разработчик решает написать immutable класс, он делает две версии этого класса — mutable и immutable.

— А в чем смысл писать два класса вместо одного?

— Иногда так выгоднее, когда неизменяемая версия объекта будет гораздо проще/быстрее чем изменяемая. Тогда и делают две версии. Это почти как ArrayList и LinkedList: оба — списки, но один оптимизирован для одних целей, второй — для других.

— Бывают также и чисто immutable классы, без их mutable версии.

— А если мне нужно что-то поменять в таком объекте? Что вообще можно сделать с неизменяемым объектом?

— Обычно immutable классы содержат различные методы, которые «как бы» меняют объект, но вместо изменения самого объекта эти методы просто создают новый объект и возвращают его.

Вот тебе несколько примеров:

String s = "moscow"; String s2 = s.toUpperCase();

Integer i = 1; Integer j = i; j++;

Класс String — это immutable класс. Все объекты типа String — неизменяемые, что, однако, не мешает нам с ними работать. Например, метод toUpperCase() класса String преобразовывает строку в верхний регистр (заменяет все маленькие буквы на большие). Но этот метод не меняет саму строку, а возвращает новую строку, которая идентична первой, только все символы в верхнем регистре (большие).

Класс Integer — это тоже immutable класс. Все объекты типа Integer — неизменяемые. Каждый раз, когда мы изменяем объект Integer, на самом деле создается новый объект.

— Как интересно. Ура, Билаабо.

Источник