Java Interview Review
6.1K members
13 photos
261 links
Популярные вопросы и ответы с собеседований на Java-разработчика.

Канал для Android-разработчиков @AndroidSobes

Связаться с нами @SobesAdmin

http://itsobes.ru/
Download Telegram
to view and join the conversation
Как узнать IP по имени хоста?

Для этого в пакете java.net стандартной библиотеки существует класс InetAddress, и два его наследника – Inet4Address и Inet6Address, для IPv4 и IPv6 соответственно.

Один хост может разрешаться в несколько адресов. Статический метод getAllByName возвращает по хосту список IP (представленных классами InetAddress). При неудачном разрешении выбрасывается UnknownHostException. Метод getByName вернет один, первый попавшийся хост. Разрешенный адрес хоста сохраняется в кэше.

На работу классов пакета java.net влияют некоторые сетевые настройки JVM. До Java 9 можно было сконфигурировать службу для разрешения имен (DNS). Обратите внимание, теперь такая возможность пропала, и всегда используется стандартная служба системы.

#Сеть
Как изменить значение приватного финального поля?

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

Для этого трюка необходимо прибегнуть к использованию Reflection API.

Сначала получим дескриптор поля – экземпляр класса Field. У объекта метакласса Class<X> интересующего нас класса вызовем метод getDeclaredField(). Просто getField() не сработает, потому что он работает только с публичными полями. Параметром передается строка с именем поля.

Полученного экземпляра Field уже достаточно для доступа к изменяемым приватным полям. Перед обращением требуется сделать его доступным, вызвав setAccessible(true).

Сам доступ осуществляется методами get*() и set*(). Так как Field представляет дескриптор поля класса, без привязки к конкретному экземпляру класса, экземпляр передается параметром в методы доступа. Для статического поля передается null.

Чтобы побороть неизменяемость финального поля, нужно снять его модификатор final. Все модификаторы поля хранятся в поле modifiers дескриптора. То есть, нужно также с помощью рефлекшена сделать доступным и обновить поле уже объекта Field.

Поле modifiers хранит модификаторы в виде битовой маски. Для изменения придется прибегнуть к битовым операторам.

Полный код установки значения 42 в поле myField объекта myObject выглядит так:
Field field = myObject.class.getDeclaredField( "myField" );
field.setAccessible( true );
Field modifiersField = Field.class.getDeclaredField( "modifiers" );
modifiersField.setAccessible( true );
modifiersField.setInt( field, field.getModifiers() & ~Modifier.FINAL );
field.setInt(myObject, 42);


#Классы
#пятница

Современная разработка немыслима без систем контроля версий вроде Git. Сыграйте в обучающую игру – научитесь продвинутому использованию этого мощнейшего инструмента.

https://learngitbranching.js.org/
Как написать простейшее клиент-серверное приложение?

Без применения дополнительных библиотек, основа низкоуровневого сетевого взаимодействия в Java строится на двух классах: Socket и ServerSocket.

Socket – клиентское подключение. Отправляет запросы и получает ответы с заданного порта/адреса по TCP/IP-соединению. Наследники могут реализовывать протоколы более высокого уровня сетевого стека, например SSLSocket. Похож на утилиту netcat из Unix-систем. Обслуживает одно подключение к серверу, обменивается данными через InputStream и OutputStream.

ServerSocket – сервер, приёмник подключений. Занимает на машине заданный свободный порт, и в одиночку принимает все подключения к нему. Опционально можно задать свой адрес, если текущая машина доступна по нескольким, а сокет должен быть доступен только по одному из них.

Ключевой метод серверного сокета – accept(). Вызов этого метода блокирует исполнение до тех пор, пока не придет новый запрос от клиента. Возвращает пришедший запрос в виде экземпляра класса Socket. Чтобы сделать сервер параллельным, accept() должен вызываться в параллельных потоках.

Стандартную внутреннюю реализацию сокетов можно подменить, установив для них статическую фабрику типа SocketImplFactory, методом setSocketFactory().

Для высокоуровневых (HTTP, FTP) запросов в стандартной библиотеке есть класс URLConnection и его наследники.

Полный пример клиент-серверного приложения доступен в туториале на сайте Oracle.

#Сеть
Что такое ForkJoinPool?

ForkJoinPool – специальный вид ExecutorService (пулла потоков), который появился в Java с версии 7. Предназначен для выполнения рекурсивных задач.

Задача для сервиса представляется экземпляром класса ForkJoinTask. В основном используются подклассы RecursiveTask и RecursiveAction, для задач с результатом и без соответственно. Аналогично интерфейсам Callable и Runnable обычного ExecutorService.

Тело рекурсивной операции задается в реализации метода compute() задачи ForkJoinTask. Здесь же создаются новые подзадачи, и запускаются параллельно методом fork(). Чтобы дождаться завершения выполнения задачи, на каждой форкнутой подзадаче вызывается блокирующий метод join(), результат выполнения при необходимости агрегируется.

С точки зрения использования метод ForkJoinTask.join() похож на аналогичный метод класса Thread. Но в случае fork-join поток может на самом деле не заснуть, а переключиться на выполнение другой задачи. Такая стратегия называется work stealing, и позволяет эффективнее использовать ограниченное количество потоков. Это похоже на переиспользование потоков корутинах Kotlin (green threads).

Примеры практического использования ForkJoinPool.

#Многопоточность
Чем ForkJoinPool отличается от ExecutorService?

ForkJoinPool сам по себе является наследником ExecutorService. Вопрос подразумевает его отличия от обычного пула потоков – ThreadPoolExecutor.

Основное отличие – стратегия work stealing, которая уже упоминалась в предыдущем посте. Этой стратегии посвящена глава 5.3.3 Java Concurrency in Practice.

Преимущества, которые дает work stealing по сравнению с обычным пулом:
• Сокращение расходов на переключение контекста;
• Защита от проблемы голодания потоков (thread starvation);
• Защита от дедлока для рекурсивных задач.

Как положено любому представителю ExecutorService, ForkJoinPool тоже умеет выполнять Runnable и Callable, но помимо этого работает и со специальными задачами ForkJoinTask, о которых также говорилось ранее.

Интерфейс настройки и мониторинга остается тем же, что и в классических тред-пулах.

Каждый обычный пул использует собственный набор потоков. ForkJoinPool по умолчанию использует общий пул-синглтон commonPool. Альтернативный отдельный пул всё еще можно задать в конструкторе.

ForkJoinPool сам регулирует количество запущенных потоков, достигая максимальной эффективности при заданном уровне параллелизма.

#Многопоточность
Как работают стримы?

Пакет java.util.stream – это средства потоковой обработки данных в функциональном стиле. Они не имеют ничего общего (кроме названия) с потоками ввода-вывода. Типичные применения – конвертация, переупаковка, и агрегация данных.

Три основных понятия Java Stream API – источник данных, промежуточная (intermediate), и терминальная (terminal) операции.

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

Промежуточные операции модифицируют стрим. На одном потоке можно вызвать сколько угодно промежуточных операций.

Терминальная операция «потребляет» поток. Она может быть только одна, в конце работы с отдельно взятым стримом. Стримы работают лениво – вся цепочка промежуточных операций не начнет выполняться до вызова терминальной.

Типичный пример использования стримов – map-reduce. Map – промежуточная операция, reduce – терминальная.

Источники и промежуточные операции могут изменять набор характеристик потока, которые влияют на дальнейшую обработку. Операция может иметь свойства – элементы перечисления StreamOpFlag:
SORTED – можно сравнивать элементы;
ORDERED – определен порядок обхода;
DISTINCT – содержит уникальные элементы, без дублей;
SIZED – имеет определенный размер;
SHORT_CIRCUIT – операция, которая может приводить к короткому замыканию.

Для лучшего погружения рекомендуется к просмотру доклад Тагира Валеева.

#Классы
Приведите примеры операций со стримами

Самые часто используемые:

#Классы
Как реализовать собственный стрим?

Любой стрим определяется его сплитератором. Spliterator – это специальный разделяемый внутренний итератор.

Есть много способов получить готовый сплитератор или стрим, но чтобы создать полностью свою специфическую логику перебора элементов, придется написать собственный сплитератор.

Поток создается из сплитератора одним из статических методов класса StreamSupport. Вызов его методов осуществляется самим фреймворком. Вкратце его работа выглядит так:
• Элементы перебираются методом tryAdvance, пока он не выдаст false. Через параметр action к элементу применяются последующие операции.
• При применении промежуточных и терминальных операций учитываются характеристики потока, изначально задаваемые методом characteristics.
• Когда обработка стрима распараллеливается, методом trySplit от начала последовательности элементов «откусывается» часть, и возвращается завернутой в новый сплитератор. Текущий продолжает идти по оставшемуся хвосту. В идеале, по возможности эта часть – половина элементов потока. Если разделить уже нельзя, возвращается null.

Подробно и доступно последовательность действий для реализации описана в статье на хабре.

#Классы
Как работают параллельные стримы?

Основная цель, ради которой в Java 8 был добавлен Stream API – удобство многопоточной обработки.

Обычный стрим будет выполняться параллельно после вызова промежуточной операции parallel(). Некоторые стримы создаются уже многопоточными, например результат вызова Collection#parallelStream(). Для распараллеливания используется единый общий ForkJoinPool.

Внутри реализации потока его сплиттератор оборачивается в AbstractTask, который и отправляется на выполнение в пул. AbstractTask при выполнении считывает estimateSize сплиттератора и текущую степень параллелизма пула. На основе этих данных он принимает решение, распараллелить ли сплиттератор на два методом trySplit().

У удобства такого решения есть обратная сторона. Так как пул единый, нагрузка распределяется на всех пользователей параллельных стримов в программе. Если в одном потоке выполняются долгие блокирующие операции, это может ударить по производительности в совершенно не связанном с ним другом потоке.

Если всё же требуется использовать отдельный пул потоков, сам стрим выполняется как задача этого отдельного пула. Подробнее в статье.

#Классы
#Многопоточность
Как создать HashMap сразу с элементами?

Проблема с созданием Map в том, что в отличие от других коллекций инициализация должна принять параметрами набор пар неопределенного размера. Поэтому varargs здесь не подходит.

Самый примитивный, многословный, но простой способ – добавить элементы сразу после создания. Для мапы-поля класса это можно сделать в конструкторе или блоке инициализации.

Map<String, String> map = new HashMap<>();
{
map.put("one", "first");
map.put("two", "second");
}


Идиома double brace initialization. Компактная запись, которая расшифровывается компилятором как создание анонимного класса-наследника от HashMap, с добавлением элементов в блоке статической инициализации. Создание нового класса приводит к дополнительным накладным расходам, так делать не рекомендуется.

new HashMap<String, String>() {{
put("one", "first");
put("two", "second");
}};


Для специальных случаев, пустой и одноэлементной неизменяемых мап, в классе Collections есть соответствующие фабричные методы emptyMap() и singletonMap(key, value).

Удобно создавать HashMap из стрима. Коллектор Collectors.toMap(keyMapper, valueMapper) с помощью мапперов превратит объекты потока в ключи и значения.

В Java 9 наконец появились фабричные метод Map.of(), перегруженный для разного количества пар параметров, и Map.ofEntries() с varargs-аргументом.

До Java 9 подобное было реализовано во многих популярных библиотеках, например ImmutableMap.of в Guava и MapUtils.putAll() в Apache Commons.

#Коллекции
Как инстанцировать экземпляр generic типа?

Внутри класса class Foo<T> на generic параметре T невозможно выполнить никакой оператор: нельзя взять его .class, нельзя применить его в instanceof. Также и вызов на нем оператора new приведет к ошибке.

Причина этих ограничений кроется в стирании типов. Дженерик параметры правильно воспринимать скорее как ограничения типов, чем как конкретные типы. Эти ограничения действуют для более строгих проверок на этапе компиляции. В рантайме же информация о конкретных переданных типах-параметрах стирается. А все эти операторы выполняются именно в рантайме.

Стандартный простой способ действия здесь – кроме значения типа T передавать еще и объект-дескриптор для этого типа, экземпляр класса Class<T>. Объект может быть создан из дескриптора рефлекшеном.

Но существует один хак, способный справиться со стиранием типов. Тип-параметр все-таки остается в одном месте в рантайме. Метод метакласса наследника определившего конкретный тип getGenericSuperclass() возвращает класс, которым параметризован родитель.

#Классы
#Дженерики
Что означает ArrayStoreException?

Это исключение значит, что программа попыталась сохранить в массив значение неправильного типа. Такая попытка становится возможно из-за ковариантности массивов.

Ковариантность позволяет работать с массивом по типу массива родителей. Например, через приведение к Object[] можно попытаться положить любой объект в любой массив:

Object x[] = new String[3];
x[0] = new Integer(0);

Компилятор гарантирует, что когда вы берете элемент из массива, он будет представителем типа элементов самого этого массива. Не важно какого типа переменная его хранит. Именно для обеспечения этой гарантии работает проверка типа времени выполнения, которая и выбрасывает ArrayStoreException.

Ситуация похожа на проблему heap pollution в случае дженериков. Только для этого случая такая проблема возникает реже, потому что работает проверка этапа компиляции:

// Ошибка компиляции – дженерики инвариантны!
List<Object> x = new ArrayList<String>();


#Язык
#Дженерики
Как скопировать массив?

Object.clone() и System.arraycopy(). Нативные способы копирования, самые быстрые из возможных. Унаследованный от базового класса clone() копирует весь массив без лишних аргументов. arraycopy(), наоборот, максимально гибкий – позволяет копировать часть массива и указывать массив, в который копировать.

Arrays.copyOf(), Arrays.copyOfRange() и все их перегрузки. Утилитарные методы, которые дают более специализированные способы копирования. Внутри все используют System.arraycopy().

Копирование через стрим. Arrays.stream(sourceArray).toArray(). Удобно когда нужно встроить дополнительные промежуточные операции.

Сторонними библиотеками. Обычно обеспечивают дополнительные удобства, такие как проверка корректности параметров, приведения типов, и прочие. Пример – класс SerializationUtils из Apache Commons.

Все перечисленные способы создают поверхностную копию – оба массива в итоге ссылаются на одни и те же объекты. Лучший способ создать глубокую копию – реализовать ее вручную. Сначала оператором new создается пустой массив нужного размера, затем в цикле заполняется копиями элементов. Stream API здесь может дать удобный интерфейс реализации, и оптимизировать копирование с помощью многопоточности.

Самый быстрый, но ужасный по эффективности способ глубокого копирования массива без реализации копирования отдельных элементов – сериализация+десериализация. Сложно придумать оправдание такому плохому способу для продакшна, но этот метод вполне подходит для реализации быстрого прототипа, или для тестового кода.

#Язык
Можно ли поймать Error?

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

На практике, согласно спецификации, значение исключения типа Error – необрабатываемая ошибка, ловить которую нет смысла.

Более того, выброс исключения подтипа VirtualMachineError означает, что JVM находится в сломанном состоянии. Дальнейшая работа непредсказуема: OutOfMemoryError приводит к невозможности создания новых объектов, StackOverflowError теряет фреймы стека вызова, и так далее.

Так как ловить Error не нужно, объявление её в секции throws сигнатуры метода необязательно. Как и RuntimeException, Error – разновидность unchecked exception.

#Язык
#JVM
Как написать иммутабельный класс?

Immutable (неизменяемый) класс – это класс, состояние экземпляров которого невозможно изменить после создания.

С иммутабельным классом всегда легче работать. Его состояние не поменяется, значит обращаться к нему в многопоточной среде можно без дополнительной синхронизации. Функции, зависящие только от состояния экземпляра будут возвращать один и тот же результат от вызова к вызову – это облегчает например реализацию hashCode(). Также вместо нескольких одинаковых экземпляров можно использовать один закэшированный объект, экономя память (паттерн Приспособленец).

Шаги, которые необходимо предпринять, чтобы класс стал immutable:

1. Запретите расширение класса – либо объявите его final, либо закройте доступ наследникам ко всем способам мутации, перечисленным в следующих пунктах;
2. Сделайте все поля финальными;
3. Не выставляйте наружу методов-мутаторов, которые меняют состояние;
4. Не отдавайте наружу поля ссылочного изменяемого типа (объекты классов, массивы) – если объект под ссылкой не иммутабельный, должна возвращаться его глубокая копия (defensive copy);
5. Создавайте объект правильно (подробнее в следующем посте).

Если вам нужны преимущества иммутабельного объекта, но также нужно иногда изменять его, подойдет подход copy on write: каждый метод-мутатор должен мутировать и возвращать не сам объект, а только что созданную его копию. Оригинал всё так же остается неизменным.

#Классы
Как инициализировать иммутабельный класс? (1/2)

Если прочитать определение immutable-объекта внимательно, момент его создания – это единственный этап в жизненном цикле, когда объект может меняться. Действительно, как иначе установить это неизменяемое состояние. Отсюда, при неправильной реализации, вытекают некоторые риски дальнейшей неизменяемости.

Первое, самое очевидное правило: копируйте поля ссылочных типов. Когда пользователь передал в конструктор изменяемый объект, возможно он все еще владеет ссылкой на него. Тогда, пользуясь этой ссылкой, пользователь может менять поле вашего иммутабельного объекта позднее. Создав копию объекта-параметра перед присвоением в поле, вы получите эксклюзивную ссылку, недоступную извне.

Вторая проблема, с которой вы гораздо менее вероятно столкнетесь, но о которой нужно знать: без должной синхронизации в многопоточной среде конструктор может получить ссылку на не до конца сконструированный объект. Для поддержки создания объектов в многопоточной среде нужно обеспечить создание его полей happens-before. Проблема аналогична double-checked блокировке без ключевого слова volatile – детали можно почитать здесь.

#Классы
Как инициализировать иммутабельный класс? (2/2)

Что касается удобства создания immutable объектов. Если класс состоит из всего пары полей – дополнительные действия скорее всего не нужны, хватит обычного конструктора.

Однако, когда полей много, это становится проблемой. В Java, в отличие от таких языков как например TypeScript или Kotlin, нельзя указывать имена передаваемых параметров. Обычно можно воспользоваться сеттерами, но в неизменяемом классе их нет.

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

На помощь приходят порождающие паттерны. Самый распространенный подход – builder (паттерн Строитель). Для иммутабельного типа Foo создается дополнительный изменяемый класс FooBuilder. В билдере есть сеттеры для каждого поля. Эти сеттеры обычно возвращают this, что позволяет вызывать их в цепочке. Цепочка заканчивается методом build(), который уже создает иммутабельный Foo.

Каждый сеттер выполняет роль именованного параметра. Сам билдер, как обычный объект, можно передавать от компонента к компоненту, делегируя им части инициализации. Использование этого паттерна логически разделяет существование объекта типа Foo на два этапа – создание и использование.

#Классы
Как реализовать метод equals?

Сначала нужно решить, действительно ли вам нужно переопределять equals(). Реализация по умолчанию делает объект равным только самому себе (сравнение на идентичность). Это имеет смысл, если у вашего класса не бывает отдельных, но логически одинаковых экземпляров.

Если два экземпляра всё-таки могут быть равны, equals() нужно переопределять. Реализация должна соблюдать контракт: это отношение эквивалентности (рефлексивность, транзитивность, симметричность), ни один объект не равен null.

Рефлексивность. первым делом проверим, не идентичен ли переданный объект текущему. Если да – сразу вернем true.

Неравенство null. Если аргумент null – сразу вернем false.

Симметричность. Если мы допускаем наследование и расширение метода equals(), в наследнике может появиться дополнительная логика, которая сделает !other.equals(this) при this.equals(other). Проще всего избежать этого, добавив сравнение типов. Если типы не равны – сразу вернем false. Почему не надо использовать instanceof.

Транзитивность. Оператор == обладает свойствами транзитивности и симметричности. Далее мы сравниваем на равенство все примитивные свойства. Для ссылочных типов этими характеристиками по контракту обладает equals – для сравнения ссылочных типов пользуемся им.

Речь здесь идет о логических свойствах. Фактически одно логическое свойство может быть представлено несколькими полями класса, или же может вычисляться на лету. Некоторые поля служат для внутренних технических нужд, и не имеют отношения к логическому состоянию. Такие поля обычно исключают из сравнения.

#Классы
Как реализовать метод hashCode?

Если вы переопределили equals(), то обязательно также переопределить и hashCode(). Это не просто теоретическое требование. Если класс нарушает это правило, хранение его экземпляров в качестве например ключей HashMap приводит к непредсказуемому поведению.

Результат hashCode() должен быть одинаковый для равных в смысле equals объектов. Обычно для этого значение хэш-кода вычисляется на основе значений полей, которые участвуют в equals(). Но и возвращение одной и той же константы 42 для любого экземпляра класса тоже будет валидной реализацией.

Результат hashCode() должен быть равномерно распределен. Это правило не такое строгое как остальные. Его нарушение не сломает программу, хотя может сильно ухудшить производительность. Поэтому константа 42 – допустимая, но не лучшая идея. Вместо этого все значения полей сначала приводятся к int: boolean превращается в любую пару констант, null в 0, для ссылочных типов берется их hashCode(). Затем все эти значения смешиваются с помощью бинарного оператора XOR (^). Дополнительно для лучшего распределения можно применять битовые сдвиги. Если вы владеете информацией о распределении значений полей в конкретно вашем случае, эту реализацию можно улучшить.

Результат hashCode() должен быть одинаковый на протяжении времени жизни объекта. Если вычисление хэш-кода зависит от переменных значений, сохраните его значение во внутреннее поле при первом вызове. При следующих вызовах сразу возвращайте это закэшированное значение.

#Классы
Чем отличается Closeable от AutoCloseable?

Интерфейс AutoCloseable представляет объект-хранилище некоего ресурса, пока тот не закрыт. В единственном его методе close() объявляется логика закрытия этого ресурса. Пример – дескриптор открытого файла (ObjectOutputStream).

Особенность этого интерфейса в том, что его применение позволяет использовать объект в языковой конструкции try-with-resource. Всё это появилось в Java версии 7.

До Java 7 уже существовал похожий интерфейс – Closeable. Смысл его точно такой же. Он всё еще доступен в стандартной библиотеке для обратной совместимости, но в новом коде рекомендуется использовать AutoCloseable. Чтобы экземпляры старого Closeable тоже можно было использовать в try-with-resource, новый интерфейс был добавлен его родителем.

Проблема старого интерфейса Closeable была в узости типа исключений, которые может выбрасывать close(). Ковариантность позволила расширить тип в базовом интерфейсе AutoCloseable с IOException до Exception.

Еще одно отличие – контракт метода close(). Старый Closeable требует его идемпотентности, тогда как новый AutoCloseable разрешает методу иметь побочные эффекты.

#Классы
#Язык