Иммутабельность в Java
Привет, Хабр. В преддверии скорого старта курса «Подготовка к сертификации Oracle Java Programmer (OCAJP)» подготовили для вас традиционный перевод материала.
Приглашаем также всех желающих поучаствовать в открытом демо-уроке «Конструкторы и блоки инициализации». На этом бесплатном вебинаре мы:
— Разберём конструктор на запчасти
— Определим финалистов (финальные переменные)
— Наведём порядок (инициализации)
Иммутабельный (неизменяемый, immutable) класс — это класс, который после инициализации не может изменить свое состояние. То есть если в коде есть ссылка на экземпляр иммутабельного класса, то любые изменения в нем приводят к созданию нового экземпляра.
Чтобы класс был иммутабельным, он должен соответствовать следующим требованиям:
Должен быть объявлен как final, чтобы от него нельзя было наследоваться. Иначе дочерние классы могут нарушить иммутабельность.
Все поля класса должны быть приватными в соответствии с принципами инкапсуляции.
Для корректного создания экземпляра в нем должны быть параметризованные конструкторы, через которые осуществляется первоначальная инициализация полей класса.
Для исключения возможности изменения состояния после инстанцирования, в классе не должно быть сеттеров.
Для полей-коллекций необходимо делать глубокие копии, чтобы гарантировать их неизменность.
Иммутабельность в действии
Начнем со следующего класса, который, на первый взгляд, выглядит иммутабельным:
Теперь посмотрим на него в действии.
Очевидно, что мы хотим запретить добавление элементов в коллекцию, поскольку это изменение состояния объекта, то есть отсутствие иммутабельности.
Здесь мы изменили метод getFieldMap , который теперь возвращает глубокую копию коллекции, ссылка на которую есть в AlmostMutableClass . Получается, что если мы получим Map , вызвав метод getFieldMap , и добавим к нему элемент, то на map из нашего класса это никак не повлияет. Изменится только map , которую мы получили.
Однако если у нас остается доступ к исходной map , которая была передана в качестве параметра конструктору, то все не так уж и хорошо. Мы можем изменить ее, тем самым изменив состояние объекта.
Мы забыли, что в конструкторе нужно сделать то же самое, что и в методе getFieldMap . В итоге конструктор должен выглядеть так:
Хотя использование иммутабельных объектов дает преимущества, но их использование не всегда оправдано. Обычно нам нужно как создавать объекты, так и модифицировать их для отражения изменений, происходящих в системе.
То есть нам нужно изменять данные, и нелогично создавать новые объекты при каждом изменении, так как это увеличивает используемую память, а мы хотим разрабатывать эффективные приложения и оптимально использовать ресурсы системы.
Иммутабельность строк в Java
Класс String , представляющий набор символов, вероятно, самый популярный класс в Java. Его назначение — упростить работу со строками, предоставляя различные методы для их обработки.
Например, в классе String есть методы для получения символов, выделения подстрок, поиска, замены и многие другие. Как и другие классы-обертки в Java (Integer, Boolean и т.д.), класс String является иммутабельным.
Иммутабельность строк дает следующие преимущества:
Для строк можно использовать специальную область памяти, называемую «пул строк». Благодаря которой две разные переменные типа String с одинаковым значением будут указывать на одну и ту же область памяти.
Строки отличный кандидат для ключей в коллекциях, поскольку они не могут быть изменены по ошибке.
Класс String кэширует хэш-код, что улучшает производительность хеш-коллекций, использующих String .
Чувствительные данные, такие как имена пользователей и пароли, нельзя изменить по ошибке во время выполнения, даже при передаче ссылок на них между разными методами.
Как создать неизменяемый класс в Java?
Как создать неизменяемый класс в Java? Узнайте, как сделать класс неизменяемым в Java и что такое неизменяемый класс. Неизменяемые классы являются потокобезопасными.
- Автор записи
Сегодня мы узнаем о неизменяемом классе в Java. Что такое неизменяемые классы? Преимущества и важность глубокого копирования для неизменности.
Что такое неизменяемый класс в Java?
Неизменяемые объекты – это экземпляры, состояние которых не меняется после инициализации. Например, String является неизменяемым классом, и после создания экземпляра его значение никогда не меняется.
Прочитайте : Почему строка в неизменяемом в Java
Преимущества неизменяемого класса в Java
Неизменяемый класс хорош для целей кэширования, потому что вам не нужно беспокоиться об изменениях значений.
Еще одним преимуществом неизменяемого класса является то , что он по своей сути потокобезопасен, поэтому вам не нужно беспокоиться о безопасности потоков в случае многопоточной среды.
Прочитайте : Учебник по потокам Java и Вопросы для многопоточного интервью Java .
Здесь я предлагаю способ создания неизменяемого класса на примере для лучшего понимания.
Как создать неизменяемый класс в Java?
Чтобы создать неизменяемый класс в Java, вам необходимо выполнить следующие действия.
- Объявите класс окончательным, чтобы его нельзя было расширить.
- Сделайте все поля закрытыми, чтобы прямой доступ был запрещен.
- Не предоставляйте методы настройки для переменных.
- Сделайте все изменяемые поля окончательными , чтобы его значение можно было присвоить только один раз.
- Инициализируйте все поля с помощью конструктора , выполнив глубокое копирование.
- Выполните клонирование объектов в методах получения, чтобы вернуть копию, а не фактическую ссылку на объект.
Чтобы понять пункты 4 и 5, давайте запустим пример конечного класса, который хорошо работает, и значения не изменяются после создания экземпляра.
Чтобы понять пункты 4 и 5, давайте запустим пример конечного класса, который хорошо работает, и значения не изменяются после создания экземпляра.
Результатом приведенного выше примера программы является:
Почему глубокое копирование важно для неизменности?
Давайте прокомментируем конструктор, предоставляющий глубокую копию, и раскомментируем конструктор, предоставляющий неглубокую копию.
Кроме того, раскомментируйте оператор return в методе getTestMap () , который возвращает фактическую ссылку на объект.
Запустите программу после того, как все изменения будут сделаны. Это приведет к следующему результату.
Как вы можете видеть из выходных данных, значения хэш-карты изменились из-за неглубокого копирования в конструкторе.
Это происходит из-за прямой ссылки на исходный объект в функции getter.
Это все для неизменяемого класса в Java. Мы также узнали о важности глубокого копирования для неизменяемых классов.
Дальнейшее чтение : Если неизменяемый класс имеет много атрибутов, и некоторые из них являются необязательными, мы можем использовать шаблон builder для создания неизменяемых классов .
Java Core. Вопросы к собеседованию, ч. 1
Неизменяемый класс – это класс, состояние которого не может быть изменено после создания. Здесь состоянием объекта по существу считаются значения, хранимые в экземпляре класса, будь то примитивные типы или ссылочные типы.
Для того чтобы сделать класс неизменяемым, необходимо выполнить следующие условия:
- Не предоставляйте сеттеры или методы, которые изменяют поля или объекты, ссылающиеся на поля. Сеттеры подразумевают изменение состояния объекта а это то, чего мы хотим тут избежать.
- Сделайте все поля final и private . Поля, обозначенные private , будут недоступными снаружи класса, а обозначение их final гарантирует, что вы не измените их даже случайно.
- Не разрешайте субклассам переопределять методы. Самый простой способ это сделать – объявить класс как final . Финализированные классы в Java не могут быть переопределены.
- Всегда помните, что ваши экземпляры переменных могут быть либо изменяемыми, либо неизменяемыми. Определите их и возвращайте новые объекты со скопированным содержимым для всех изменяемых объектов (ссылочные типы). Неизменяемые переменные (примитивные типы) могут быть безопасно возвращены без дополнительных усилий.
Также, вам необходимо помнить последующие преимущества неизменяемых классов. Возможно они понадобятся вас на собеседовании. Неизменяемые классы:
- легко конструировать, тестировать и использовать
- автоматически потокобезопасны и не имеют проблем синхронизации
- не требуют конструктора копирования
- позволяют выполнить «ленивую инициализацию» хэшкода и кэшировать возвращаемое значение
- не требуют защищенного копирования, когда используются как поле
- делают хорошие Map ключи и Set элементы (эти объекты не должны менять состояние, когда находятся в коллекции)
- делают свой класс постоянным, единожды создав его, а он не нуждается в повторной проверке
- всегда имеют «атомарность по отношению к сбою» (failure atomicity, термин применил Джошуа Блох): если неизменяемый объект бросает исключение, он никогда не останется в нежелательном или неопределенном состоянии.
Посмотрите на пример, написанный в этом посте.
В Java передача по значению или по ссылке?
Java спецификация гласит, что все в Java передается по значению. Нет такого понятия, как «передача по ссылке» в Java. Эти условия связаны с вызовом методов и передачей переменных, как параметров метода. Хорошо, примитивные типы всегда передаются по значению без какой-либо путаницы. Но, концепция должна быть понятна в контексте параметра метода сложных типов.
В Java, когда мы передает ссылку сложного типа как любой параметр метода, всегда адрес памяти копируется в новую ссылочную переменную шаг за шагом. Посмотрите на изображение:
В приведенном примере, биты адреса первого экземпляра копируются другой ссылочной переменной, в результате чего обе ссылки указывают на один участок памяти, где хранится объект. Помните, что присвоив второй ссылке null, вы не присвоите null первой ссылке. Но изменение состояния объекта с одной ссылающейся переменной, будет отображено и в другой ссылке.
Какое применение блока finally ? Гарантирует этот блок выполнение своего кода? Когда finally блок не вызывается?
Блок finally всегда вызывается, если блок try существует. Это гарантирует, что блок finally вызывается даже, если случается неожиданное исключение. Но finally является более полезным, чем просто для обработки исключений – этот блок позволяет выполнить чистку кода, случайно обошедшего через return , continue или break . Размещение очищающего кода в блок finally всегда является хорошей практикой, даже когда не ожидается никаких исключений.
Если виртуальная машина завершает работу во время выполнения блока try или catch , тогда блок finally не будет выполнен. Аналогично, если нить, выполняя блок try или catch , будет прервана или убита, блок finally не будет выполнен, даже не смотря на то, что приложение продолжает работать.
Почему существует два класса Date , один в java.util package а другой в java.sql ?
java.util.Date представляет дату и время, а java.sql.Date представляет только дату. Дополнением к java.sql.Date является класс java.sql.Time , который представляет только время.
Класс java.sql.Date является субклассом (расширением) класса java.util.Date . Итак, что изменилось в java.sql.Date :
- toString() формирует другое представление строки: yyyy-mm-dd
- статический метод valueOf(String) создает дату из строки с вышеуказанным представлением
- исключены геттеры и сеттеры для часов, минут и секунд
Класс java.sql.Date используется в JDBC и предназначен, чтобы не иметь составляющую времени, то есть часы, минуты, секунды и миллисекунды должны быть нулю… но это не является обязательным для класса.
Разъясните интерфейсы-маркеры.
Шаблон интерфейса-маркера – это шаблон проектирования в компьютерных науках, используемый языками программирования, которые предоставляют информацию об объектах во время выполнения. Это предоставляет способ ассоциации метаданных класса, где язык не имеет явной поддержки таких метаданных. В Java для этого используются интерфейсы без указания методов.
Хорошим примером применения интерфейса-маркера в Java является интерфейс Serializable . Класс реализует этот интерфейс для указания, что его не transient данные могут быть записаны в поток байтов или на файловую систему.
Главной проблемой интерфейса-маркера является то, что интерфейс определяет соглашение для реализующих его классов, и это соглашение наследуется всеми субклассами. Это значит, что вы не сможете «де-реализовать» маркер. В приведенном примере, если вы создадите субкласс, который вы бы не хотели сериализовать (возможно потому, что он находится в преходящем (transient) состоянии), вы должны прибегнуть к явному бросанию NotSerializableException .
Почему метод main() объявлен как public static void ?
Почему public? Метод main имеет модификатор доступа public , поэтому он может быть доступен везде и для любого объекта, который захочет использовать этот метод для запуска приложения. Тут я не говорю, что JDK/JRE имеют подобный повод, поскольку java.exe или javaw.exe (для windows) используют Java Native Interface (JNI) вызов для запуска метода, поэтому они могут вызвать его в любом случае, независимо от модификатора доступа.
Почему static? Давайте предположим, что у нас метод main не статический. Теперь, для вызова любого метода вам необходим экземпляр класса. Верно? Java разрешает иметь перегруженные конструкторы, это мы все знаем. Тогда который из них должен быть использован, и откуда возьмутся параметры для перегруженного конструктора?
Почему void? Нет применения для возвращаемого значения в виртуальной машине, которая фактически вызывает этот метод. Единственное, что приложение захочет сообщить вызвавшему процессу – это нормальное или ненормальное завершение. Это уже возможно используя System.exit(int) . Не нулевое значение подразумевает ненормальное завершение, иначе все в порядке.
В чем разница между созданием строки как new() и литералом (при помощи двойных кавычек)?
Когда мы создаем строку используя new() , она создается в хипе и также добавляется в пул строк, в то же время строка, созданная при помощи литерала, создается только в пуле строк.
Вам необходимо ознакомиться с понятием пула строк глубже, чтобы ответить на этот или подобные вопросы. Мой совет – как следует выучите класс String и пул строк.
Как работает метод substring() класса String ?
Как и в других языках программирования, строки в Java являются последовательностью символов. Этот класс больше похож на служебный класс для работы с этой последовательностью. Последовательность символов обеспечивается следующей переменной:
Каждый раз, когда мы создаем подстроку от существующего экземпляра строки, метод substring() только устанавливает новые значения переменных offset и count . Внутренний массив символов не изменяется. Это возможный источник утечки памяти, если метод substring() использовать неосторожно:
Первоначальное значение value[] не изменяется. Поэтому если вы создадите строку длиной 10000 символов и создадите 100 подстрок с 5-10 символами в каждой, все 101 объекты будут содержать один и тот же символьный массив длиной 10000 символов. Это без сомнения расточительство памяти.
Этого можно избежать, изменив код следующим образом:
заменить original.substring(beginIndex) на new String(original.substring(beginIndex)) , где original – исходная строка.
Объясните работу HashMap . Как решена проблема дубликатов?
Большинство из вас наверняка согласится, что HashMap наиболее любимая тема для дискуссий на интервью в настоящее время. Если кто-нибудь попросит меня рассказать «Как работает HashMap ?», я просто отвечу: «По принципу хэширования». Так просто, как это есть.
Итак, хеширование по сути является способом назначить уникальный код для любой переменной/объекта после применения любой формулы/алгоритма к своим свойствам.
Определение карты ( Map ) таково: «Объект, который привязывает ключи к значениям». Очень просто, верно? Итак, HashMap содержит собственный внутренний класс Entry , который имеет вид:
Когда кто-либо пытается поместить пару ключ-значение в HashMap , происходит следующее:
- В первую очередь, объект ключа проверяется на null . Если ключ null , значение сохраняется в позицию table[0] . Потому что хэшкод для null всегда 0.
- Затем, следующим шагом вычисляется хэш значение вызывая у переменной-ключа свой метод hashCode() . Этот хэш используется для вычисления индекса в массиве для хранение объекта Entry . Разработчики JDK прекрасно понимали, что метод hashCode() может быть плохо написан и может возвращать очень большое или очень маленькое значение. Для решения этой проблемы они ввели другой hash() метод, и передают хэшкод объекта этому методу для приведения этого значения к диапазону размера индекса массива.
- Теперь вызывается метод indexFor(hash, table.length) для вычисления точной позиции для хранения объекта Entry .
- Теперь главная часть. Как мы знаем, два неодинаковых объекта могут иметь одинаковое значение хэшкода, как два разных объекта будет храниться в одинаковом расположении в архиве [называется корзиной]?
Ответ – LinkedList . Если вы помните, класс Entry имеет свойство “next”. Это свойство всегда указывает на следующий объект в цепи. Такое поведение очень похоже на LinkedList .
Итак, в случае совпадений хэшкодов, объекты Entry хранятся в форме LinkedList . Когда объект Entry необходимо разместить на конкретном индексе, HashMap проверяет, существует ли на этом месте другой объект Entry ? Если там нет записи, наш объект сохранится в этом месте.
Если на нашем индексе уже находится другой объект, проверяется его поле next . Если оно равно null , наш объект становится следующим узлом в LinkedList . Если next не равно null , эта процедура повторяется, пока не будет найдено поле next равное null .
Что будет, если мы добавим другое значение ключа, равное добавленному ранее? Логично, что оно должно заменить старое значение. Как это происходит? После определения индекса позиции для объекта Entry , пробегая по LinkedList , расположенному на нашем индексе, HashMap вызывает метод equals() для значения ключа для каждого объекта Entry . Все эти объекты Entry в LinkedList имеют одинаковое значение хэшкода, но метод equals() будет проверять на настоящее равенство. Если ключ. equals(k) будет true, тогда оба будут восприниматься как одинаковый объект. Это вызовет замену только объекта-значение внутри объекта Entry .
Таким образом HashMap обеспечивает уникальность ключей.
Различия между интерфейсами и абстрактными классами?
Это очень распространенный вопрос, если вы проходите собеседование на программиста уровня junior. Наиболее значимые различия приведены ниже:
- В интерфейсах Java переменные априори final . Абстрактные классы могут содержать не final переменные.
- Интерфейс в Java безоговорочно не может иметь реализации. Абстрактный класс может иметь экземпляры методов, которые реализуют базовое поведение.
- Составляющие интерфейса должны быть public . Абстрактный класс может иметь модификаторы доступа на любой вкус.
- Интерфейс должен быть реализован ключевым словом implements . Абстрактный класс должен быть расширен при помощи ключевого слова extends.
- В Java класс может реализовывать множество интерфейсов, но может унаследоваться только от одного абстрактного класса.
- Интерфейс полностью абстрактный и не может иметь экземпляров. Абстрактный класс также не может иметь экземпляров класса, но может быть вызван, если существует метод main() .
- Абстрактный класс слегка быстрее интерфейса, потому что интерфейс предполагает поиск перед вызовом любого переопределенного метода в Java. В большинстве случаев это незначительное различие, но если вы пишите критичное по времени приложение, вам необходимо учесть и этот факт.
Когда вы переопределяете методы hashCode() и equals() ?
Методы hashCode() и equals() определены у класса Object , который является родительским классом для всех объектов Java. По этой причине, все объекты Java наследуют базовую реализацию этих методов.
Метод hashCode() используется для получения уникального значения integer для данного объекта. Это значение используется для определения расположения корзины, когда объект необходимо хранить в структуре данных наподобие HashTable . По умолчанию метод hashCode() возвращает целочисленное представление адреса памяти, где хранится объект.
Метод equals() , как предполагает название, используется для простой эквивалентности объектов. Базовая реализация метода заключается в проверке ссылок двух объектов для проверки их эквивалентности.
Обратите внимание, что обычно необходимо переопределять метод hashCode() всякий раз, когда переопределен метод equals() . Это необходимо для поддержки общего соглашения метода hashCode , в котором говорится что равные объекты должны иметь равные хэшкоды.
Метод equals() должен определять равенство отношений (он должен быть возвратным, симметричным и транзитивным). В дополнение, он должен быть устойчивым (если объект не изменялся, метод должен возвращать то же самое значение). Кроме того, o.equals(null) всегда должно возвращать false.
hashCode() должен быть также устойчивым (если объект не изменялся по условиям метода equals() , он должен продолжать возвращать то же самое значение.