Java Interview Tasks

Чему будет равно d3?

Ответ на вопрос про try-catch-with-resources:
Напечатается "try", так как в случае когда вылетает ексепшн внутри try-catch и при закрытии ресурса, то второй эксепшен добавляется в поле suppressedExceptions в основном эксепшене.

Что напечатает код? (Внутри try-catch выбрасывается эксепшен, а потом, при закрытии ресурса, вылетает еще один ексепшен)

С Новым годом 🎆🍾🎄🎁🎉

Ответ на задачу про ассерт:
Если a равно NaN, то проверка if (a == 0.0) будет ложной, и будет AssertionError();, поскольку NaN не равен ни нулю, ни любому другому числу. В данном коде стоит добавить проверку if(Double.isNaN(a))

Может ли этот код выбросить AssertionError?

Забирай пошаговую roadmap по JAVA

FAANG School в течение 24 часов отдают бесплатно свою библиотеку знаний. Вы можете получить доступ:

– Redis - 5 улучшений для твоего пет-проекта
– Пошаговая RoadMap по Java
– Мануал по Docker. Основные команды и концепции
– Микросервисы. Вопросы с собеседований
– Шпаргалка с горячими клавишами JetBrains IDE. Ускоришь работу в 10 раз
– Desk setup. Подборка аксессуаров для комфортной работы
– Шпаргалка по Kafka
– Шпаргалка по Spring с разбором паттерна Наблюдатель
– Инструкция по работе с Git
– Подробный гайд, как найти работу в IT без опыта
– Подборка платформ с вакансиями для java-разработчиков

Свежее пополнение - то, без чего не обойтись ни одному джуну - шпаргалка по основным командам SQL!

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

Ответ на задачу про два кубика:
Каждый кубик имеет 6 граней, поэтому общее количество возможных комбинаций при броске двух кубиков: [ 6 * 6 = 36 ] Это означает, что при броске двух кубиков существует 36 возможных разных исходов.
Теперь определим все комбинации двух кубиков, которые в сумме дают 6. Рассмотрим все возможные пары чисел:
(1, 5)
(2, 4)
(3, 3)
(4, 2)
(5, 1)
Итак, у нас есть 5 благоприятных сочетаний, где сумма равна 6.

Вероятность того, что сумма выпавших очков будет равна 6, можно вычислить по формуле: [ P = число благоприятных исходов / общее количество исходов = 5/36 ]
Ответ:
Таким образом, вероятность того, что сумма очков на двух кубиках будет равна 6, составляет 5/36.

Вы бросаете два кубика. Каждый кубик имеет 6 граней. Какова вероятность того, что сумма выпавших очков будет равна 6?

Ответ на вопрос про == для строк:
Правильный ответ - true, true
Здесь все строки это ссылки на один и тот же объект в пуле строк, пэтому сравнение == возвращает тру.
Про пул строк:
Когда в коде создается строка через строковый литерал (например, String s = "Hello";), JVM сначала проверяет пул строк. Если строка с таким же значением уже присутствует в пуле, то новый объект не создается. Вместо этого переменной s присваивается ссылка на уже существующий объект в пуле. Если же такой строки в пуле нет, JVM создает новый объект строки в пуле и возвращает ссылку на него.

Это поведение отличается от создания строк через оператор new (например, String s = new String("Hello");). В этом случае в куче всегда создается новый объект String, независимо от того, содержится ли такая же строка в пуле строк или нет.

Что напечатает код при вызове конструктора?

Ответ на вопрос про Collectors.toList() vs Stream.toList():
Collectors.toList() возвращает ArrayList и поэтому shuffle отрабатывает корректно, но Stream.toList() всегда возвращает реализацию списка, которая не может быть изменена. И поэтому shuffle упадет с java.lang.UnsupportedOperationException.
Поэтому верный ответ - напечатается «2»

Что напечатает код?

Ответ на вопрос про Multimap.forEach:
Правильный ответ 3, проще всего понять причину, если в forEach добавить типы параметров:
map.forEach((Integer key, String values) -> i.getAndIncrement());
Тогда видно, что "String values" это одно "value", а не "values", еще больше запутывает название параметра "values"
Для примера результат работы кода выше будет такой:
1=one
1=two
1=three

Что напечатает код?

Чему равны переменные a и b?

Для d.equals(-0.0): false
Объяснение: Метод equals() для объектов типа Double сравнивает их значения, но в этом случае сравнение 0.0 и -0.0 возвращает false, поскольку equals() также учитывает знак.

Для d == -0.0: true
Объяснение: Оператор == сравнивает значения, и в Java 0.0 и -0.0 считаются равными несмотря на различные знаки, поэтому выражение возвращает true.

Таким образом, результаты выполнения данного кода:

d.equals(-0.0) вернет false
d == -0.0 вернет true

Давайте разберем, почему так сделано в Java.
Оператор == при сравнении примитивных типов (включая double) сравнивает их численные значения, игнорируя знак. Таким образом, 0.0 и -0.0 считаются равными, поскольку в контексте числовых вычислений они представляют одно и то же количество: нулевая величина.

Java использует стандарт IEEE 754 для представления чисел с плавающей точкой, в котором существуют два разных значения для нуля: +0.0 и -0.0. Однако, когда речь идет о сравнении значений, стандарт допускает равенство этих двух значений.

Метод equals() является методом класса Object и может быть переопределён. В случае класса Double, метод equals() не только сравнивает значения, но и учитывает знак числа.

Метод equals() в Double реализован так, что он воспринимает 0.0 и -0.0 как разные значения. Это сделано для поддержки точного различения, которое может быть важно в некоторых математических или инженерных расчётах. Например, в контексте некоторых алгоритмов или в области численной линейной алгебры знак может играть важную роль.

Чит код для новичков в IT

Изучите фреймворк Hibernate. В 98% случаев данные веб приложений хранятся в SQL базах, а с Hibernate работа с ними станет в десятки раз проще.

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

FAANG School сделали эфир, на котором расскажут все, чтобы раз и навсегда разобраться с этим фреймворком:

– зачем нужен и как применять Hibernate в своих собственных Java-проектах
– как создавать связи между Java-объектами и таблицами в базе данных
– лучшие практики Hibernate для создания топ-приложений
– как просто работать со связями one-to-one, one-to-many и many-to-many и многое другое

Занимайте место - они ограничены.

Узнаете, как выполнять SQL запросы прямо из Java кода, а также глубоко изучите в Hibernate и как правильно его использовать, чтобы быстро реагировать на любой вопрос на собеседовании. Переходите, подробности здесь.

Значение переменной allMatch равно true. Значение переменной anyMatch будет false

По спецификации Java Streams, allMatch возвращает true, если стрим не содержит элементов. Это связано с тем, что условие "все элементы удовлетворяют предикату" считается выполненным, если нет элементов, которые могли бы его не удовлетворить.
Результат выполнения:
Следовательно, значение переменной allMatch будет true.

Метод anyMatch проверяет, удовлетворяет ли хотя бы один элемент стрима заданному условию (в данном случае предикату, проверяющему, содержит ли строка символ "a").

По спецификации Java Streams, метод anyMatch возвращает false, если стрим не содержит элементов. Это связано с тем, что условие "хотя бы один элемент удовлетворяет предикату" не может быть выполнено в пустом потоке.

Следовательно, значение переменной anyMatch будет false.

Уже завтра собеседование на Middle Java с разработчиком из МТС

20 ноября (уже завтра!) в 19:00 по мск приходи онлайн на открытое собеседование, чтобы посмотреть на настоящее интервью на Middle Java-разработчика.

Как это будет:
1. Мария Ядерцова ведущий Java-разработчик в МТС Диджитал и ex. Сбербанк-Технологии будет задавать реальные вопросы и задачи разработчику-добровольцу
2. Мария будет комментировать каждый ответ респондента, чтобы дать понять чего от вас ожидает собеседующий на интервью
3. В конце можно будет задать любой вопрос Марии

Что узнаешь на прямом эфире от ШОРТКАТ:
• Чего ждут от кандидатов на Middle позиции в Java-разработке
• Какие вопросы задают на интервью и зачем
• Как подготовиться к собесу, чтобы получить оффер

Это бесплатно? Бесплатно

Переходи в нашего бота, чтобы получить ссылку на эфир → @shortcut_sh_bot

Реклама. ООО "ШОРТКАТ", ИНН: 9731139396, erid: 2VtzqvQXaJ2

Чему равно значение переменной allMatch?

Чему равно значение переменной anyMatch?

Решение задачи про три монеты:
Определяем вероятности выбора монет:

У вас есть 3 монеты, и каждая монета имеет равные шансы быть выбранной. Это значит, что вероятность выбора каждой монеты равна 1/3.
Рассмотрим возможные исходы при выборе каждой монеты:

Первая монета (О, О): При подбрасывании этой монеты, вы всегда получите орел, поскольку у монеты оба lados — орлы.
Вторая монета (Р, Р): При подбрасывании этой монеты, вы никогда не получите орел, так как у нее только решки.
Третья монета (О, Р): При подбрасывании этой монеты, вы получите орел с вероятностью 50%, так как у нее один орел и одна решка.
Считаем шансы получить орел:

Теперь оценим, сколько случаев из возможных приведут к получению орла:
Из 3-х монет:
1-я монета всегда дает орел (1 случай).
2-я монета никогда не дает орел (0 случаев).
3-я монета дает орел в половине случаев (1 случай из 2, то есть 0.5).
Объединяем результаты:

У нас есть:
1 случай из 1 (первая монета).
0 случаев из 1 (вторая монета).
0.5 случаев из 1 (третья монета).
Тогда общее количество случаев, когда мы получаем орел:
( 1 + 0 + 0.5 = 1.5 )
Общее количество подбрасываний:

Поскольку мы выбираем одну из трех монет, фактически общее количество попыток — это 1 (от первой монеты) + 1 (от второй) + 0.5 (от третьей).
Таким образом, общее количество подбрасываний — 3 (так как мы рассматриваем сжатый вариант из природы случайной выборки).
Находим вероятность:

Таким образом, общая вероятность получения орла: [ P(орел) = 1.5/3 = 1/2 ]
Ответ:
Вероятность того, что выпал орел, составляет ( 1/2 ) или 50%.

У вас есть 3 монеты:
Первая монета имеет 2 орла (О, О).
Вторая монета имеет 2 решки (Р, Р).
Третья монета имеет 1 орел и 1 решка (О, Р).
Вы случайным образом выбираете одну монету и подбрасываете ее.
Какова вероятность того, что выпал орел?

Ответ на вопрос про -1 * 0.0 :
Когда вы выполняете выражение -1 * 0.0 в Java, результат будет -0.0. Давайте разберем, почему это происходит.

В математике любое число, умноженное на 0, всегда дает 0. Однако в языке программирования, таком как Java, 0 может быть представлен как 0.0 (положительный ноль с плавающей точкой) и -0.0 (отрицательный ноль с плавающей точкой). Обратите внимание, что это не просто разные представления одного и того же числа — они могут повлиять на поведение программ, которые используют их.

В данном случае 0.0 — это значение с плавающей точкой, и операция умножения с -1 (который является целым числом) автоматически приводит -1 к типу double для выполнения операции. Таким образом, -1 * 0.0 выполняется как -1.0 * 0.0.

Когда вы умножаете -1.0 * 0.0, результатом будет -0.0. В Java, значение -0.0 действительно существует и может быть использовано, например, в сравнениях или в других математических операциях.

Что напечатает код?

Пояснение к to0_100Range():
Тут неправильное использование Math.min и Math.max: используется Math.max(value, 100), чтобы ограничить значение, но при этом вызывается Math.min(0, ...).
Это означает, что если value не меньше 100, то после выполнения этой операции value будет всегда 0, так как Math.min(0, ...) вернет 0 независимо от второго аргумента, если он больше 0.
Ожидаемое поведение - предполагается, что надо ограничить value в диапазоне от 0 до 100, включая крайние значения. Однако текущий код этого не делает. На самом деле, после выполнения этой строки:

Если value меньше 100, но больше 0, то ваше значение будет 0.
Если value больше 100, то оно останется 0 из-за Math.min.
Корректное решение:
Для ограничения значения value в диапазоне от 0 до 100, вы можете воспользоваться следующим кодом:
value = Math.max(0, Math.min(value, 100));

Правильно ли работает метод?

Проблемы метода isOdd:
Метод будет правильно работать для положительных нечетных чисел, но он не будет правильно обрабатывать отрицательные нечетные числа. В частности, для отрицательных нечетных чисел, остаток от деления на 2 будет -1, что не соответствует условию. Например:
Для value = -3, возвращаемое значение будет равно:
-3 % 2 == -1 // это не то, что мы ожидаем, метод вернет false

Чтобы метод корректно определял нечетность для всех целых чисел (как положительных, так и отрицательных), вы можете использовать такую реализацию:

public boolean isOdd(int value) {
return value % 2 != 0;
}

Правильно ли реализован метод?

Ответ на вопрос про количество примитивных типов в java:

В Java существует восемь примитивных типов данных:

byte - 8-битное целое число.
short - 16-битное целое число.
int - 32-битное целое число.
long - 64-битное целое число.
float - 32-битное число с плавающей точкой.
double - 64-битное число с плавающей точкой.
char - 16-битный символ (представляет символ в кодировке UTF-16).
boolean - логический тип (может принимать значения true или false).

О чем хотите поговорить: low-latency-сервисах, переходе на Cassandra или тестировании?

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

Что узнаете из докладов:

— Как разработчики Т-Банка переехали на Cassandra. Будет полезно, если начинаете использовать систему или думаете на нее переходить.
— Когда и как нужно писать low-latency-сервисы. Пригодится, если думаете, что на Java нельзя писать быстрый код.

Что обсудят на дискуссии:

— Основы тестирования, виды тестов и их применение в реальных ситуациях.
— Преимущества и недостатки юнит-тестов.
— Значимость покрытия кода тестами и подходы к оценке качества.
— Влияние внешних интеграций на процесс тестирования.

Встреча пройдет 30 октября на Кремлевской набережной, зд. 33, в крытом парке «Урам».

Участие бесплатное. Узнайте больше и успейте зарегистрироваться

Ответ на вопрос про Math.abs:

Когда вы вызываете Math.abs(Integer.MIN_VALUE) в Java, результатом будет Integer.MIN_VALUE, и вы получите отрицательное значение. Давайте разберемся, почему так происходит.

Метод Math.abs() возвращает абсолютное значение числа. То есть он возвращает положительное значение, если число отрицательное, и само число, если оно положительное.

Integer.MIN_VALUE представляет собой наименьшее возможное значение для типа int в Java, которое равно -2,147,483,648 (или −(2^31)).

Когда вы вызываете Math.abs(-2,147,483,648), метод пытается вернуть положительное значение этого числа. Однако в диапазоне int не существует представления для 2,147,483,648, так как максимальное положительное значение int — это 2,147,483,647 (или 2^31 - 1).
Следовательно, попытка преобразовать Integer.MIN_VALUE в положительное значение приводит к переполнению.

По сути, когда Math.abs() пытается вернуть -(-2,147,483,648), это значение не может быть представлено в типе int, и в результате вы получите Integer.MIN_VALUE, а не ожидаемое положительное число.

Как вариант решения можно использовать Math.absExact, он в этом случае кидает ArithmeticError.
Так же обратите внимание на метод Math.floorMod как замену для Math.abs() % intVal

Есть ли проблемы в этом коде?

#ВП
Делюсь самой топовой 🔝 подборкой каналов, которые ведут профи своего дела и раскрывают важные темы в сфере: Разработки и Аналитики ⬇️

Не нужно больше искать тематические каналы и тратит на это кучу времени — уже всё тут

Нажимай на ссылку ниже:
💻 https://t.me/addlist/d23m2d_lHE42MjAy

и следи за каналами, чтобы держать руку на пульсе и первым получать самую актуальную информацию ✔️

Ответ на вопрос про Integer.MIN_VALUE/-Integer.MIN_VALUE:
Выражение System.out.println(Integer.MIN_VALUE == -Integer.MIN_VALUE); выводит true.
Давайте поймем почему так:
Integer.MIN_VALUE — это константа в Java, представляющая наименьшее возможное значение для типа int. Для 32-битного целочисленного типа это значение равно -2,147,483,648 (или −(2^31)).

Когда мы берем отрицательное значение от Integer.MIN_VALUE, мы вычисляем:
-Integer.MIN_VALUE = -(-2,147,483,648) = 2,147,483,648
Однако 2,147,483,648 не может быть представлено в типе int, так как максимальное значение для int — это 2,147,483,647 (или 2^31 - 1). Поэтому при попытке установить такое значение происходит переполнение.

При преобразовании 2,147,483,648 в тип int происходит переполнение. Оно «оборачивается» назад по кругу и становится равным Integer.MIN_VALUE, то есть -2,147,483,648.

Что напечатает код?

Разъяснение вопроса про get/set name:
В коде метод main создает экземпляр класса B, устанавливает значение имени с помощью метода setName, а затем выводит значение имени с помощью метода getName. Однако выводится null, и это может быть непонятным на первый взгляд. Давайте разберемся в чем дело.

Класс A содержит поле name, которое является закрытым (private) и имеет геттер getName, который возвращает значение этого поля.
Класс B наследуется от класса A, но в нем есть собственное закрытое поле name и метод setName, который устанавливает значение этого поля.

Когда вы вызываете b.setName("name");, вы устанавливаете значение локального поля name в классе B, а не в классе A. Поэтому поле name в классе A по-прежнему остается null.

Когда вызывается System.out.println(b.getName());, этот метод берёт значение поля name из класса A, которое не было изменено, и таким образом возвращает null.

Что напечатает код?

Ответ на вопрос про перевод секунд в микросекунды:
Правильный ответ тут будет 705032704 из-за переполнения int.
При умножении двух целочисленных значений Java выполняет умножение с использованием типа int. Если результат этого умножения превышает максимальное значение, которое может храниться в int (которое составляет 2,147,483,647), происходит переполнение, что приводит к неправильному поведению.

Чтобы избежать этой проблемы при работе с большими числами, можно убедиться, что умножение выполняется с использованием типа long, добавив суффикс L к числу, на которое вы умножаете (в данном случае 1_000_000L). Это повысит уровень операции умножения до long, который имеет гораздо большее максимальное значение (до 9,223,372,036,854,775,807).

Вот исправленная строка кода:
long microseconds = seconds * 1_000_000L;

Что напечатает код?

Ответ на вопрос про перемножение iSet и jSet:
Элементов 8, так как 0 .0 и -0.0 считаются уникальными значениями
В стандартном IEEE 754, который используется для представления чисел с плавающей точкой, существуют два разных значения для нуля:

0.0 (положительный ноль)
-0.0 (отрицательный ноль)
В Java, хотя 0.0 и -0.0 эквивалентны при использовании оператора ==, они могут рассматриваться как отдельные значения:

HashSet использует hashCode() для определения уникальности объектов, и метод hashCode() для Double возвращает разные хэш-коды для 0.0 и -0.0. Из-за этого оба значения могут храниться в HashSet.

Таким образом, result будет содержать:
0.0 (положительный ноль)
-0.0 (отрицательный ноль)
0.25
-0.25
0.5
-0.5
1.0
-1.0

Поэтому result.size() возвращает 8, поскольку 0.0 и -0.0 считаются разными значениями в HashSet из-за нюансов представления чисел с плавающей точкой в Java (см. IEEE 754).

Сколько элементов будет в result?

Ответ на задачу про вычисление среднего: При использовании выражения LongStream.of(Long.MAX_VALUE, Long.MAX_VALUE) внутренняя работа функции average() сначала вычисляет сумму элементов. Поскольку оба значения равны Long.MAX_VALUE, сумма превышает Long.MAX_VALUE: [ Long.MAX_VALUE + Long.MAX_VALUE = 2 \times (2^{63} - 1) = 2^{64} - 2 ] Однако 2^{64} - 2 не может быть представлено типом long (она превышает Long.MAX_VALUE), в результате чего происходит переполнение.

Поскольку sum фактически переполняется и становится отрицательным (из-за переполнения), результатом вычисления среднего может стать отрицательное значение, что является контринтуитивным.

Чему равно v?

Решение задачи про удаленную работу:
Процент сотрудников на удаленке: 20% (то есть из 100 сотрудников 20 работают на удаленке и 80 — в офисе).
Вероятность, что удаленный сотрудник работает меньше 8 часов: 50% (из 20 удаленных сотрудников, 10 работают меньше 8 часов).
Вероятность, что офисный сотрудник работает меньше 8 часов: 10% (из 80 офисных сотрудников, 8 работают меньше 8 часов).

Считаем общее количество сотрудников, которые работают меньше 8 часов.
Удаленные сотрудники: 10 (из 20).
Офисные сотрудники: 8 (из 80).
Итого сотрудников, работающих меньше 8 часов: [ 10 + 8 = 18 ]
Выясняем, сколько из работающих меньше 8 часов — это удаленные сотрудники.
У нас 10 удаленных сотрудников, которые работают меньше 8 часов.
Теперь находим долю удаленных сотрудников среди всех, кто работает меньше 8 часов.

Из 18 сотрудников, работающих меньше 8 часов, 10 являются удаленными.
Вероятность того, что сотрудник работает на удаленке, если он работает меньше 8 часов:

Это 10 удаленных сотрудников из 18 работающих меньше 8 часов: [ 10/18 = 0.56 ]
Ответ:
Таким образом, вероятность того, что сотрудник работает на удаленке, если он работает меньше 8 часов в день, составляет примерно 56%

В компании 20% сотрудников работают на удаленке. Если сотрудник работает на удаленке, то вероятность того, что он работает каждый день меньше 8 часов, составляет 50%. Если сотрудник работает в офисе, то вероятность того, что он работает меньше , составляет 10%. Вопрос: Какова вероятность того, что сотрудник работает на удаленке, если известно, что он работает меньше 8 часов в день?

Здесь перед присваиванием будет выполнено целочисленное деление, в результате которого дробная часть будет отбрасываться. В результате переменная half никогда не будет содержать дробную часть, и, например, функции process(2) и process(3) будут возвращать один и тот же результат.

Способы избежать этой ошибки:
Будьте внимательны при делении. Всегда спрашивайте себя, хотите ли вы получить округленный результат или вам нужна дробная часть.

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

double half = value / 2.0; (явная константа double 2.0)
double half = (double) value / 2; (явный оператор приведения)