First release
This commit is contained in:
enhorse
commit
37716acc5d
|
|
@ -0,0 +1,10 @@
|
|||
# IntelliJ
|
||||
*.iml
|
||||
out/
|
||||
.idea/
|
||||
|
||||
# System specific
|
||||
.DS_Store
|
||||
|
||||
# Maven
|
||||
target/
|
||||
|
|
@ -0,0 +1,730 @@
|
|||
#Вопросы для собеседования на Java Junior
|
||||
|
||||
+ [ООП](#ООП) ![icon][done]
|
||||
+ [Java Core](#java-core) ![icon][done]
|
||||
+ [Java Collections Framework](#java-collections) ![icon][done]
|
||||
+ [Java 8](#java-8) ![icon][done]
|
||||
+ [Потоки ввода-вывода в Java](#Потоки-вводавывода-в-java) ![icon][done]
|
||||
+ [Сериализация](#Сериализация) ![icon][done]
|
||||
+ [Многопоточность](#Многопоточность) ![icon][done]
|
||||
+ [Servlets, JSP, JSTL](#servlets-jsp-jstl) ![icon][done]
|
||||
+ [Базы данных](#Базы-данных) ![icon][done]
|
||||
+ [SQL](#sql) ![icon][done]
|
||||
+ [JDBC](#jdbc) ![icon][done]
|
||||
+ [Тестирование](#Тестирование) ![icon][done]
|
||||
+ [Журналирование](#Журналирование) ![icon][done]
|
||||
+ [UML](#uml) ![icon][done]
|
||||
+ [XML](#xml) ![icon][done]
|
||||
+ [Шаблоны проектирования](#Шаблоны-проектирования) ![icon][done]
|
||||
+ [Основы HTML](#Основы-html) ![icon][done]
|
||||
+ [Основы CSS](#Основы-css) ![icon][done]
|
||||
+ [Основы Web](#Основы-web) ![icon][done]
|
||||
|
||||
[done]:done.png
|
||||
|
||||
##ООП
|
||||
+ [Что такое _ООП_?](oop.md#Что-такое-ООП)
|
||||
+ [Назовите основные принципы _ООП_.](oop.md#Назовите-основные-принципы-ООП)
|
||||
+ [Что такое _«инкапсуляция»_?](oop.md#Что-такое-инкапсуляция)
|
||||
+ [Что такое _«наследование»_?](oop.md#Что-такое-наследование)
|
||||
+ [Что такое _«полиморфизм»_?](oop.md#Что-такое-полиморфизм)
|
||||
+ [Что такое _«абстракция»_?](oop.md#Что-такое-абстракция)
|
||||
+ [Что представляет собой _«обмен сообщениями»_?](oop.md#Что-представляет-собой-обмен-сообщениями)
|
||||
+ [Расскажите про основные понятия ООП: _«класс»_, _«объект»_, _«интерфейс»_.](oop.md#Расскажите-про-основные-понятия-ООП-класс-объект-интерфейс)
|
||||
+ [В чем заключаются преимущества и недостатки объектно-ориентированного подхода в программировании?](oop.md#В-чем-заключаются-преимущества-и-недостатки-объектно-ориентированного-подхода-в-программировании)
|
||||
+ [Что подразумевают в плане принципов ООП выражения _«является»_ и _«имеет»_?](oop.md#Что-подразумевают-в-плане-принципов-ООП-выражения-является-и-имеет)
|
||||
+ [В чем разница между _композицией_ и _агрегацией_?](oop.md#В-чем-разница-между-композицией-и-агрегацией)
|
||||
+ [Что такое _статическое_ и _динамическое связывание_?](oop.md#Что-такое-статическое-и-динамическое-связывание)
|
||||
|
||||
[к оглавлению](#Вопросы-для-собеседования-на-java-junior)
|
||||
|
||||
##Java Core
|
||||
+ [Чем различаются JRE, JVM и JDK?](core.md#Чем-различаются-jre-jvm-и-jdk)
|
||||
+ [Какие существуют модификаторы доступа?](core.md#Какие-существуют-модификаторы-доступа)
|
||||
+ [О чем говорит ключевое слово `final`?](core.md#О-чем-говорит-ключевое-слово-final)
|
||||
+ [Какими значениями инициализируются переменные по умолчанию?](core.md#Какими-значениями-инициализируются-переменные-по-умолчанию)
|
||||
+ [Что вы знаете о функции `main()`?](core.md#Что-вы-знаете-о-функции-main)
|
||||
+ [Какие логические операции и операторы вы знаете?](core.md#Какие-логические-операции-и-операторы-вы-знаете)
|
||||
+ [Что такое тернарный оператор выбора?](core.md#Что-такое-тернарный-оператор-выбора)
|
||||
+ [Какие побитовые операции вы знаете?](core.md#Какие-побитовые-операции-вы-знаете)
|
||||
+ [Где и для чего используется модификатор `abstract`?](core.md#Где-и-для-чего-используется-модификатор-abstract)
|
||||
+ [Дайте определение понятию _«интерфейс»_. Какие модификаторы по умолчанию имеют поля и методы интерфейсов?](core.md#Дайте-определение-понятию-интерфейс-Какие-модификаторы-по-умолчанию-имеют-поля-и-методы-интерфейсов)
|
||||
+ [Чем абстрактный класс отличается от интерфейса? В каких случаях следует использовать абстрактный класс, а в каких интерфейс?](core.md#Чем-абстрактный-класс-отличается-от-интерфейса-В-каких-случаях-следует-использовать-абстрактный-класс-а-в-каких-интерфейс)
|
||||
+ [Почему в некоторых интерфейсах вообще не определяют методов?](core.md#Почему-в-некоторых-интерфейсах-вообще-не-определяют-методов)
|
||||
+ [Почему нельзя объявить метод интерфейса с модификатором `final`?](core.md#Почему-нельзя-объявить-метод-интерфейса-с-модификатором-final)
|
||||
+ [Что имеет более высокий уровень абстракции - класс, абстрактный класс или интерфейс?](core.md#Что-имеет-более-высокий-уровень-абстракции---класс-абстрактный-класс-или-интерфейс)
|
||||
+ [Может ли объект получить доступ к `private`-переменной класса? Если, да, то каким образом?](core.md#Может-ли-объект-получить-доступ-к-private-переменной-класса-Если-да-то-каким-образом)
|
||||
+ [Каков порядок вызова конструкторов и блоков инициализации с учётом иерархии классов?](core.md#Каков-порядок-вызова-конструкторов-и-блоков-инициализации-с-учётом-иерархии-классов)
|
||||
+ [Зачем нужны и какие бывают блоки инициализации?](core.md#Зачем-нужны-и-какие-бывают-блоки-инициализации)
|
||||
+ [К каким конструкциям Java применим модификатор `static`?](core.md#К-каким-конструкциям-java-применим-модификатор-static)
|
||||
+ [Для чего в Java используются статические блоки инициализации?](core.md#Для-чего-в-java-используются-статические-блоки-инициализации)
|
||||
+ [Что произойдёт, если в блоке инициализации возникнет исключительная ситуация?](core.md#Что-произойдёт-если-в-блоке-инициализации-возникнет-исключительная-ситуация)
|
||||
+ [Какое исключение выбрасывается при возникновении ошибки в блоке инициализации класса?](core.md#Какое-исключение-выбрасывается-при-возникновении-ошибки-в-блоке-инициализации-класса)
|
||||
+ [Может ли статический метод быть переопределён или перегружен?](core.md#Может-ли-статический-метод-быть-переопределён-или-перегружен)
|
||||
+ [Могут ли нестатические методы перегрузить статические?](core.md#Могут-ли-нестатические-методы-перегрузить-статические)
|
||||
+ [Можно ли сузить уровень доступа/тип возвращаемого значения при переопределении метода?](core.md#Можно-ли-сузить-уровень-доступатип-возвращаемого-значения-при-переопределении-метода)
|
||||
+ [Возможно ли при переопределении метода изменить: модификатор доступа; возвращаемый тип; тип аргумента или их количество; имена аргументов или их порядок, убирать, добавлять, изменять порядок следования элементов секции `throws`?](core.md#Возможно-ли-при-переопределении-метода-изменить-модификатор-доступа-возвращаемый-тип-тип-аргумента-или-их-количество-имена-аргументов-или-их-порядок-убирать-добавлять-изменять-порядок-следования-элементов-секции-throws)
|
||||
+ [Как получить доступ к переопределенным методам родительского класса?](core.md#Как-получить-доступ-к-переопределенным-методам-родительского-класса)
|
||||
+ [Можно ли объявить метод абстрактным и статическим одновременно?](core.md#Можно-ли-объявить-метод-абстрактным-и-статическим-одновременно)
|
||||
+ [В чем разница между членом экземпляра класса и статическим членом класса?](core.md#В-чем-разница-между-членом-экземпляра-класса-и-статическим-членом-класса)
|
||||
+ [Где разрешена инициализация статических/нестатических полей?](core.md#Где-разрешена-инициализация-статическихнестатических-полей)
|
||||
+ [Какие типы классов бывают в java?](core.md#Какие-типы-классов-бывают-в-java)
|
||||
+ [Расскажите про вложенные классы. В каких случаях они применяются?](core.md#Расскажите-про-вложенные-классы-В-каких-случаях-они-применяются)
|
||||
+ [Что такое _«статический класс»_?](core.md#Что-такое-статический-класс)
|
||||
+ [Какие существуют особенности использования вложенных классов: статических и внутренних? В чем заключается разница между ними?](core.md#Какие-существуют-особенности-использования-вложенных-классов-статических-и-внутренних-В-чем-заключается-разница-между-ними)
|
||||
+ [Что такое _«локальный класс»_? Каковы его особенности?](core.md#Что-такое-локальный-класс-Каковы-его-особенности)
|
||||
+ [Что такое _«анонимные классы»_? Где они применяются?](core.md#Что-такое-анонимные-классы-Где-они-применяются)
|
||||
+ [Каким образом из вложенного класса получить доступ к полю внешнего класса?](core.md#Каким-образом-из-вложенного-класса-получить-доступ-к-полю-внешнего-класса)
|
||||
+ [Для чего используется оператор `assert`?](core.md#Для-чего-используется-оператор-assert)
|
||||
+ [Для чего нужен сборщик мусора?](core.md#Для-чего-нужен-сборщик-мусора)
|
||||
+ [Как работает сборщик мусора?](core.md#Как-работает-сборщик-мусора)
|
||||
+ [Какие разновидности сборщиков мусора реализованы в виртуальной машине HotSpot?](core.md#Какие-разновидности-сборщиков-мусора-реализованы-в-виртуальной-машине-hotspot)
|
||||
+ [Опишите алгоритм работы какого-нибудь сборщика мусора реализованного в виртуальной машине HotSpot.](core.md#Опишите-алгоритм-работы-какого-нибудь-сборщика-мусора-реализованного-в-виртуальной-машине-hotspot)
|
||||
+ [Что такое `finalize()`? Зачем он нужен?](core.md#Что-такое-finalize-Зачем-он-нужен)
|
||||
+ [Что произойдет со сборщиком мусора, если выполнение метода `finalize()` требует ощутимо много времени, или в процессе выполнения будет выброшено исключение?](core.md#Что-произойдет-со-сборщиком-мусора-если-выполнение-метода-finalize-требует-ощутимо-много-времени-или-в-процессе-выполнения-будет-выброшено-исключение)
|
||||
+ [Чем отличаются `final`, `finally` и `finalize()`?](core.md#Чем-отличаются-final-finally-и-finalize)
|
||||
+ [Что такое Heap и Stack память в Java? Какая разница между ними?](core.md#Что-такое-heap-и-stack-память-в-java-Какая-разница-между-ними)
|
||||
+ [Верно ли утверждение, что примитивные типы данных всегда хранятся в стеке, а экземпляры ссылочных типов данных в куче?](core.md#Верно-ли-утверждение-что-примитивные-типы-данных-всегда-хранятся-в-стеке-а-экземпляры-ссылочных-типов-данных-в-куче)
|
||||
+ [Каким образом передаются переменные в методы, по значению или по ссылке?](core.md#Каким-образом-передаются-переменные-в-методы-по-значению-или-по-ссылке)
|
||||
+ [Расскажите про приведение типов. Что такое понижение и повышение типа?](core.md#Расскажите-про-приведение-типов-Что-такое-понижение-и-повышение-типа)
|
||||
+ [Когда в приложении может быть выброшено исключение `ClassCastException`?](core.md#Когда-в-приложении-может-быть-выброшено-исключение-classcastexception)
|
||||
+ [Что такое _autoboxing («автоупаковка»)_ в Java и каковы правила упаковки примитивных типов в классы-обертки?](core.md#Что-такое-autoboxing-автоупаковка-в-java-и-каковы-правила-упаковки-примитивных-типов-в-классы-обертки)
|
||||
+ [Какие есть особенности класса `String`?](core.md#Какие-есть-особенности-класса-string)
|
||||
+ [Что такое «пул строк»?](core.md#Что-такое-пул-строк)
|
||||
+ [Почему `String` неизменяемый и финализированный класс?](core.md#Почему-string-неизменяемый-и-финализированный-класс)
|
||||
+ [Почему `char[]` предпочтительнее `String` для хранения пароля?](core.md#Почему-char-предпочтительнее-string-для-хранения-пароля)
|
||||
+ [Почему строка является популярным ключом в `HashMap` в Java?](core.md#Почему-строка-является-популярным-ключом-в-hashmap-в-java)
|
||||
+ [Что делает метод `intern()` в классе `String`?.](core.md#Что-делает-метод-intern-в-классе-string)
|
||||
+ [Можно ли мы использовать строки в конструкции `switch`?](core.md#Можно-ли-мы-использовать-строки-в-конструкции-switch)
|
||||
+ [Какая основная разница между `String`, `StringBuffer`, `StringBuilder`?](core.md#Какая-основная-разница-между-string-stringbuffer-stringbuilder)
|
||||
+ [Что такое класс `Object`? Какие в нем есть методы?](core.md#Что-такое-класс-object-Какие-в-нем-есть-методы)
|
||||
+ [Расскажите про клонирование объектов.](core.md#Расскажите-про-клонирование-объектов)
|
||||
+ [В чем отличие между _поверхностным_ и _глубоким_ клонированием?](core.md#В-чем-отличие-между-поверхностным-и-глубоким-клонированием)
|
||||
+ [Какой способ клонирования предпочтительней?](core.md#Какой-способ-клонирования-предпочтительней)
|
||||
+ [Почему метод `clone()` объявлен в классе `Object`, а не в интерфейсе `Cloneable`?](core.md#Почему-метод-clone-объявлен-в-классе-object-а-не-в-интерфейсе-cloneable)
|
||||
+ [Дайте определение понятию «конструктор».](core.md#Дайте-определение-понятию-конструктор)
|
||||
+ [Что такое _«конструктор по умолчанию»_?](core.md#Что-такое-конструктор-по-умолчанию)
|
||||
+ [Чем отличаются конструкторы по-умолчанию, копирования и конструктор с параметрами?](core.md#Чем-отличаются-конструкторы-по-умолчанию-копирования-и-конструктор-с-параметрами)
|
||||
+ [Где и как вы можете использовать закрытый конструктор?](core.md#Где-и-как-вы-можете-использовать-закрытый-конструктор)
|
||||
+ [Расскажите про классы-загрузчики и про динамическую загрузку классов.](core.md#Расскажите-про-классы-загрузчики-и-про-динамическую-загрузку-классов)
|
||||
+ [Что такое _Reflection_?](core.md#Что-такое-reflection)
|
||||
+ [Зачем нужен `equals()`. Чем он отличается от операции `==`?](core.md#Зачем-нужен-equals-Чем-он-отличается-от-операции-)
|
||||
+ [`equals()` порождает отношение эквивалентности. Какими свойствами обладает такое отношение?](core.md#equals-порождает-отношение-эквивалентности-Какими-свойствами-обладает-такое-отношение)
|
||||
+ [Если вы хотите переопределить `equals()`, какие условия должны удовлетворяться для переопределенного метода?](core.md#Если-вы-хотите-переопределить-equals-какие-условия-должны-удовлетворяться-для-переопределенного-метода)
|
||||
+ [Правила переопределения метода `Object.equals()`.](core.md#Правила-переопределения-метода-objectequals)
|
||||
+ [Какая связь между `hashCode()` и `equals()`?](core.md#Какая-связь-между-hashcode-и-equals)
|
||||
+ [Если `equals()` переопределен, есть ли какие-либо другие методы, которые следует переопределить?](core.md#Если-equals-переопределен-есть-ли-какие-либо-другие-методы-которые-следует-переопределить)
|
||||
+ [Что будет, если переопределить `equals()` не переопределяя `hashCode()`? Какие могут возникнуть проблемы?](core.md#Что-будет-если-переопределить-equals-не-переопределяя-hashcode-Какие-могут-возникнуть-проблемы)
|
||||
+ [Каким образом реализованы методы `hashCode()` и `equals()` в классе `Object`?](core.md#Каким-образом-реализованы-методы-hashcode-и-equals-в-классе-object)
|
||||
+ [Для чего нужен метод `hashCode()`?](core.md#Для-чего-нужен-метод-hashcode)
|
||||
+ [Правила переопределения метода `Object.hashCode()`.](core.md#Правила-переопределения-метода-objecthashcode)
|
||||
+ [Есть ли какие-либо рекомендации о том, какие поля следует использовать при подсчете `hashCode()`?](core.md#Есть-ли-какие-либо-рекомендации-о-том-какие-поля-следует-использовать-при-подсчете-hashcode)
|
||||
+ [Могут ли у разных объектов быть одинаковые `hashCode()`?](core.md#Могут-ли-у-разных-объектов-быть-одинаковые-hashcode)
|
||||
+ [Если у класса `Point{int x, y;}` реализовать метод `equals(Object that) {(return this.x == that.x && this.y == that.y)}`, но сделать хэш-код в виде `int hashCode() {return x;}`, то будут ли корректно такие точки помещаться и извлекаться из `HashSet`?](core.md#Если-у-класса-pointint-x-y-реализовать-метод-equalsobject-that-return-thisx--thatx--thisy--thaty-но-сделать-хэш-код-в-виде-int-hashcode-return-x-то-будут-ли-корректно-такие-точки-помещаться-и-извлекаться-из-hashset)
|
||||
+ [Могут ли у разных объектов `(ref0 != ref1)` быть `ref0.equals(ref1) == true`?](core.md#Могут-ли-у-разных-объектов-ref0--ref1-быть-ref0equalsref1--true)
|
||||
+ [Могут ли у разных ссылок на один объект `(ref0 == ref1)` быть `ref0.equals(ref1) == false`?](core.md#Могут-ли-у-разных-ссылок-на-один-объект-ref0--ref1-быть-ref0equalsref1--false)
|
||||
+ [Можно ли так реализовать метод `equals(Object that) {return this.hashCode() == that.hashCode()}`?](core.md#Можно-ли-так-реализовать-метод-equalsobject-that-return-thishashcode--thathashcode)
|
||||
+ [В `equals()` требуется проверять, что аргумент `equals(Object that)` такого же типа что и сам объект. В чем разница между `this.getClass() == that.getClass()` и `that instanceof MyClass`?](core.md#В-equals-требуется-проверять-что-аргумент-equalsobject-that-такого-же-типа-что-и-сам-объект-В-чем-разница-между-thisgetclass--thatgetclass-и-that-instanceof-myclass)
|
||||
+ [Можно ли реализовать метод `equals()` класса `MyClass` вот так: `class MyClass {public boolean equals(MyClass that) {return this == that;}}`?](core.md#Можно-ли-реализовать-метод-equals-класса-myclass-вот-так-class-myclass-public-boolean-equalsmyclass-that-return-this--that)
|
||||
+ [Есть класс `Point{int x, y;}`. Почему хэш-код в виде `31 * x + y` предпочтительнее чем `x + y`?](core.md#Есть-класс-pointint-x-y-Почему-хэш-код-в-виде-31--x--y-предпочтительнее-чем-x--y)
|
||||
+ [Опишите иерархию исключений.](core.md#Опишите-иерархию-исключений)
|
||||
+ [Какие виды исключений в Java вы знаете, чем они отличаются?](core.md#Какие-виды-исключений-в-java-вы-знаете-чем-они-отличаются)
|
||||
+ [Что такое _checked_ и _unchecked exception_?](core.md#Что-такое-checked-и-unchecked-exception)
|
||||
+ [Какой оператор позволяет принудительно выбросить исключение?](core.md#Какой-оператор-позволяет-принудительно-выбросить-исключение)
|
||||
+ [О чем говорит ключевое слово `throws`?](core.md#О-чем-говорит-ключевое-слово-throws)
|
||||
+ [Как написать собственное («пользовательское») исключение?](core.md#Как-написать-собственное-пользовательское-исключение)
|
||||
+ [Какие существуют _unchecked exception_?](core.md#Какие-существуют-unchecked-exception)
|
||||
+ [Что такое `Error`?](core.md#Что-такое-error)
|
||||
+ [Что вы знаете о `OutOfMemoryError`?](core.md#Что-вы-знаете-о-outofmemoryerror)
|
||||
+ [Опишите работу блока _try-catch-finally_.](core.md#Опишите-работу-блока-try-catch-finally)
|
||||
+ [Что такое механизм _try-with-resources_?](core.md#Что-такое-механизм-try-with-resources)
|
||||
+ [Возможно ли использование блока _try-finally_ (без `catch`)?](core.md#Возможно-ли-использование-блока-try-finally-без-catch)
|
||||
+ [Может ли один блок `catch` отлавливать сразу несколько исключений?](core.md#Может-ли-один-блок-catch-отлавливать-сразу-несколько-исключений)
|
||||
+ [Всегда ли исполняется блок `finally`?](core.md#Всегда-ли-исполняется-блок-finally)
|
||||
+ [Существуют ли ситуации, когда блок `finally` не будет выполнен?](core.md#Существуют-ли-ситуации-когда-блок-finally-не-будет-выполнен)
|
||||
+ [Может ли метод main выбросить исключение во вне и если да, то где будет происходить обработка данного исключения?](core.md#Может-ли-метод-main-выбросить-исключение-во-вне-и-если-да-то-где-будет-происходить-обработка-данного-исключения)
|
||||
+ [Предположим, есть метод, который может выбросить `IOException` и `FileNotFoundException` в какой последовательности должны идти блоки `catch`? Сколько блоков `catch` будет выполнено?](core.md#Предположим-есть-метод-который-может-выбросить-ioexception-и-filenotfoundexception-в-какой-последовательности-должны-идти-блоки-catch-Сколько-блоков-catch-будет-выполнено)
|
||||
+ [Что такое _generics_?](core.md#Что-такое-generics)
|
||||
+ [Что такое _«интернационализация»_, _«локализация»_?](core.md#Что-такое-интернационализация-локализация)
|
||||
|
||||
[к оглавлению](#Вопросы-для-собеседования-на-java-junior)
|
||||
|
||||
##Java Collections
|
||||
+ [Что такое _«коллекция»_?](jcf.md#Что-такое-коллекция)
|
||||
+ [Назовите основные интерфейсы JCF и их реализации.](jcf.md#Назовите-основные-интерфейсы-jcf-и-их-реализации)
|
||||
+ [Расположите в виде иерархии следующие интерфейсы: `List`, `Set`, `Map`, `SortedSet`, `SortedMap`, `Collection`, `Iterable`, `Iterator`, `NavigableSet`, `NavigableMap`.](jcf.md#Расположите-в-виде-иерархии-следующие-интерфейсы-list-set-map-sortedset-sortedmap-collection-iterable-iterator-navigableset-navigablemap)
|
||||
+ [Почему `Map` — это не `Collection`, в то время как `List` и `Set` являются `Collection`?](jcf.md#Почему-map--это-не-collection-в-то-время-как-list-и-set-являются-collection)
|
||||
+ [В чем разница между классами `java.util.Collection` и `java.util.Collections`?](jcf.md#В-чем-разница-между-классами-javautilcollection-и-javautilcollections)
|
||||
+ [Что такое «fail-fast поведение»?](jcf.md#Что-такое-fail-fast-поведение)
|
||||
+ [Какая разница между fail-fast и fail-safe?](jcf.md#Какая-разница-между-fail-fast-и-fail-safe)
|
||||
+ [Приведите примеры итераторов реализующих поведение fail-safe](jcf.md#Приведите-примеры-итераторов-реализующих-поведение-fail-safe)
|
||||
+ [Чем различаются `Enumeration` и `Iterator`.](jcf.md#Чем-различаются-enumeration-и-iterator)
|
||||
+ [Как между собой связаны `Iterable` и `Iterator`?](jcf.md#Как-между-собой-связаны-iterable-и-iterator)
|
||||
+ [Как между собой связаны `Iterable`, `Iterator` и «for-each»?](jcf.md#Как-между-собой-связаны-iterable-iterator-и-for-each)
|
||||
+ [Сравните `Iterator` и `ListIterator`.](jcf.md#Сравните-iterator-и-listiterator)
|
||||
+ [Что произойдет при вызове `Iterator.next()` без предварительного вызова `Iterator.hasNext()`?](jcf.md#Что-произойдет-при-вызове-iteratornext-без-предварительного-вызова-iteratorhasnext)
|
||||
+ [Сколько элементов будет пропущено, если `Iterator.next()` будет вызван после 10-ти вызовов `Iterator.hasNext()`?](jcf.md#Сколько-элементов-будет-пропущено-если-iteratornext-будет-вызван-после-10-ти-вызовов-iteratorhasnext)
|
||||
+ [Как поведёт себя коллекция, если вызвать `iterator.remove()`?](jcf.md#Как-поведёт-себя-коллекция-если-вызвать-iteratorremove)
|
||||
+ [Как поведёт себя уже инстанциированный итератор для `collection`, если вызвать `collection.remove()`?](jcf.md#Как-поведёт-себя-уже-инстанциированный-итератор-для-collection-если-вызвать-collectionremove)
|
||||
+ [Как избежать `ConcurrentModificationException` во время перебора коллекции?](jcf.md#Как-избежать-concurrentmodificationexception-во-время-перебора-коллекции)
|
||||
+ [Какая коллекция реализует дисциплину обслуживания FIFO?](jcf.md#Какая-коллекция-реализует-дисциплину-обслуживания-fifo)
|
||||
+ [Какая коллекция реализует дисциплину обслуживания FILO?](jcf.md#Какая-коллекция-реализует-дисциплину-обслуживания-filo)
|
||||
+ [Чем отличается `ArrayList` от `Vector`?](jcf.md#Чем-отличается-arraylist-от-vector)
|
||||
+ [Зачем добавили `ArrayList`, если уже был `Vector`?](jcf.md#Зачем-добавили-arraylist-если-уже-был-vector)
|
||||
+ [Чем отличается `ArrayList` от `LinkedList`? В каких случаях лучше использовать первый, а в каких второй?](jcf.md#Чем-отличается-arraylist-от-linkedlist-В-каких-случаях-лучше-использовать-первый-а-в-каких-второй)
|
||||
+ [Что работает быстрее `ArrayList` или `LinkedList`?](jcf.md#Что-работает-быстрее-arraylist-или-linkedlist)
|
||||
+ [Какое худшее время работы метода `contains()` для элемента, который есть в `LinkedList`?](jcf.md#Какое-худшее-время-работы-метода-contains-для-элемента-который-есть-в-linkedlist)
|
||||
+ [Какое худшее время работы метода `contains()` для элемента, который есть в `ArrayList`?](jcf.md#Какое-худшее-время-работы-метода-contains-для-элемента-который-есть-в-arraylist)
|
||||
+ [Какое худшее время работы метода `add()` для `LinkedList`?](jcf.md#Какое-худшее-время-работы-метода-add-для-linkedlist)
|
||||
+ [Какое худшее время работы метода `add()` для `ArrayList`?](jcf.md#Какое-худшее-время-работы-метода-add-для-arraylist)
|
||||
+ [Необходимо добавить 1 млн. элементов, какую структуру вы используете?](jcf.md#Необходимо-добавить-1-млн-элементов-какую-структуру-вы-используете)
|
||||
+ [Как происходит удаление элементов из `ArrayList`? Как меняется в этом случае размер `ArrayList`?](jcf.md#Как-происходит-удаление-элементов-из-arraylist-Как-меняется-в-этом-случае-размер-arraylist)
|
||||
+ [Предложите эффективный алгоритм удаления нескольких рядом стоящих элементов из середины списка, реализуемого `ArrayList`.](jcf.md#Предложите-эффективный-алгоритм-удаления-нескольких-рядом-стоящих-элементов-из-середины-списка-реализуемого-arraylist)
|
||||
+ [Сколько необходимо дополнительной памяти при вызове `ArrayList.add()`?](jcf.md#Сколько-необходимо-дополнительной-памяти-при-вызове-arraylistadd)
|
||||
+ [Сколько выделяется дополнительно памяти при вызове `LinkedList.add()`?](jcf.md#Сколько-выделяется-дополнительно-памяти-при-вызове-linkedlistadd)
|
||||
+ [Оцените количество памяти на хранение одного примитива типа `byte` в `LinkedList`?](jcf.md#Оцените-количество-памяти-на-хранение-одного-примитива-типа-byte-в-linkedlist)
|
||||
+ [Оцените количество памяти на хранение одного примитива типа `byte` в `ArrayList`?](jcf.md#Оцените-количество-памяти-на-хранение-одного-примитива-типа-byte-в-arraylist)
|
||||
+ [Для `ArrayList` или для `LinkedList` операция добавления элемента в середину (`list.add(list.size()/2, newElement)`) медленнее?](jcf.md#Для-arraylist-или-для-linkedlist-операция-добавления-элемента-в-середину-listaddlistsize2-newelement-медленнее)
|
||||
+ [В реализации класса `ArrayList` есть следующие поля: `Object[] elementData`, `int size`. Объясните, зачем хранить отдельно `size`, если всегда можно взять `elementData.length`?](jcf.md#В-реализации-класса-arraylist-есть-следующие-поля-object-elementdata-int-size-Объясните-зачем-хранить-отдельно-size-если-всегда-можно-взять-elementdatalength)
|
||||
+ [Сравните интерфейсы `Queue` и `Deque`.](jcf.md#Сравните-интерфейсы-queue-и-deque)
|
||||
+ [Кто кого расширяет: `Queue` расширяет `Deque`, или `Deque` расширяет `Queue`?](jcf.md#Кто-кого-расширяет-queue-расширяет-deque-или-deque-расширяет-queue)
|
||||
+ [Почему `LinkedList` реализует и `List`, и `Deque`?](jcf.md#Почему-linkedlist-реализует-и-list-и-deque)
|
||||
+ [`LinkedList` — это односвязный, двусвязный или четырехсвязный список?](jcf.md#linkedlist--это-односвязный-двусвязный-или-четырехсвязный-список)
|
||||
+ [Как перебрать элементы `LinkedList` в обратном порядке, не используя медленный `get(index)`?](jcf.md#Как-перебрать-элементы-linkedlist-в-обратном-порядке-не-используя-медленный-getindex)
|
||||
+ [Что позволяет сделать `PriorityQueue`?](jcf.md#Что-позволяет-сделать-priorityqueue)
|
||||
+ [`Stack` считается «устаревшим». Чем его рекомендуют заменять? Почему?](jcf.md#stack-считается-устаревшим-Чем-его-рекомендуют-заменять-Почему)
|
||||
+ [Зачем нужен `HashMap`, если есть `Hashtable`?](jcf.md#Зачем-нужен-hashmap-если-есть-hashtable)
|
||||
+ [В чем разница между `HashMap` и `IdentityHashMap`? Для чего нужна `IdentityHashMap`?](jcf.md#В-чем-разница-между-hashmap-и-identityhashmap-Для-чего-нужна-identityhashmap)
|
||||
+ [В чем разница между `HashMap` и `WeakHashMap`? Для чего используется `WeakHashMap`?](jcf.md#В-чем-разница-между-hashmap-и-weakhashmap-Для-чего-используется-weakhashmap)
|
||||
+ [В `WeakHashMap` используются WeakReferences. А почему бы не создать `SoftHashMap` на SoftReferences?](jcf.md#В-weakhashmap-используются-weakreferences-А-почему-бы-не-создать-softhashmap-на-softreferences)
|
||||
+ [В `WeakHashMap` используются WeakReferences. А почему бы не создать `PhantomHashMap` на PhantomReferences?](jcf.md#В-weakhashmap-используются-weakreferences-А-почему-бы-не-создать-phantomhashmap-на-phantomreferences)
|
||||
+ [`LinkedHashMap` - что в нем от `LinkedList`, а что от `HashMap`?](jcf.md#linkedhashmap---что-в-нем-от-linkedlist-а-что-от-hashmap)
|
||||
+ [В чем проявляется «сортированность» `SortedMap`, кроме того, что `toString()` выводит все элементы по порядку?](jcf.md#В-чем-проявляется-сортированность-sortedmap-кроме-того-что-tostring-выводит-все-элементы-по-порядку)
|
||||
+ [Как устроен `HashMap`?](jcf.md#Как-устроен-hashmap)
|
||||
+ [Согласно Кнуту и Кормену существует две основных реализации хэш-таблицы: на основе открытой адресации и на основе метода цепочек. Как реализована `HashMap`? Почему, по вашему мнению, была выбрана именно эта реализация? В чем плюсы и минусы каждого подхода?](jcf.md#Согласно-Кнуту-и-Кормену-существует-две-основных-реализации-хэш-таблицы-на-основе-открытой-адресации-и-на-основе-метода-цепочек-Как-реализована-hashmap-Почему-по-вашему-мнению-была-выбрана-именно-эта-реализация-В-чем-плюсы-и-минусы-каждого-подхода)
|
||||
+ [Как работает `HashMap` при попытке сохранить в него два элемента по ключам с одинаковым `hashCode()`, но для которых `equals() == false`?](jcf.md#Как-работает-hashmap-при-попытке-сохранить-в-него-два-элемента-по-ключам-с-одинаковым-hashcode-но-для-которых-equals--false)
|
||||
+ [Какое начальное количество корзин в `HashMap`?](jcf.md#Какое-начальное-количество-корзин-в-hashmap)
|
||||
+ [Какова оценка временной сложности операций над элементами из `HashMap`? Гарантирует ли `HashMap` указанную сложность выборки элемента?](jcf.md#Какова-оценка-временной-сложности-операций-над-элементами-из-hashmap-Гарантирует-ли-hashmap-указанную-сложность-выборки-элемента)
|
||||
+ [Возможна ли ситуация, когда `HashMap` выродится в список даже с ключами имеющими разные `hashCode()`?](jcf.md#Возможна-ли-ситуация-когда-hashmap-выродится-в-список-даже-с-ключами-имеющими-разные-hashcode)
|
||||
+ [В каком случае может быть потерян элемент в `HashMap`?](jcf.md#В-каком-случае-может-быть-потерян-элемент-в-hashmap)
|
||||
+ [Почему нельзя использовать `byte[]` в качестве ключа в `HashMap`?](jcf.md#Почему-нельзя-использовать-byte-в-качестве-ключа-в-hashmap)
|
||||
+ [Какова роль `equals()` и `hashCode()` в `HashMap`?](jcf.md#Какова-роль-equals-и-hashcode-в-hashmap)
|
||||
+ [Каково максимальное число значений `hashCode()`?](jcf.md#Каково-максимальное-число-значений-hashcode)
|
||||
+ [Какое худшее время работы метода get(key) для ключа, которого нет в `HashMap`?](jcf.md#Какое-худшее-время-работы-метода-getkey-для-ключа-которого-нет-в-hashmap)
|
||||
+ [Какое худшее время работы метода get(key) для ключа, который есть в `HashMap`?](jcf.md#Какое-худшее-время-работы-метода-getkey-для-ключа-который-есть-в-hashmap)
|
||||
+ [Сколько переходов происходит в момент вызова `HashMap.get(key)` по ключу, который есть в таблице?](jcf.md#Сколько-переходов-происходит-в-момент-вызова-hashmapgetkey-по-ключу-который-есть-в-таблице)
|
||||
+ [Сколько создается новых объектов, когда вы добавляете новый элемент в `HashMap`?](jcf.md#Сколько-создается-новых-объектов-когда-вы-добавляете-новый-элемент-в-hashmap)
|
||||
+ [Как и когда происходит увеличение количества корзин в `HashMap`?](jcf.md#Как-и-когда-происходит-увеличение-количества-корзин-в-hashmap)
|
||||
+ [Объясните смысл параметров в конструкторе `HashMap(int initialCapacity, float loadFactor)`.](jcf.md#Объясните-смысл-параметров-в-конструкторе-hashmapint-initialcapacity-float-loadfactor)
|
||||
+ [Будет ли работать `HashMap`, если все добавляемые ключи будут иметь одинаковый `hashCode()`?](jcf.md#Будет-ли-работать-hashmap-если-все-добавляемые-ключи-будут-иметь-одинаковый-hashcode)
|
||||
+ [Как перебрать все ключи `Map`?](jcf.md#Как-перебрать-все-ключи-map)
|
||||
+ [Как перебрать все значения `Map`?](jcf.md#Как-перебрать-все-значения-map)
|
||||
+ [Как перебрать все пары «ключ-значение» в `Map`?](jcf.md#Как-перебрать-все-пары-ключ-значение-в-map)
|
||||
+ [В чем отличия `TreeSet` и `HashSet`?](jcf.md#В-чем-отличия-treeset-и-hashset)
|
||||
+ [Что будет, если добавлять элементы в `TreeSet` по возрастанию?](jcf.md#Что-будет-если-добавлять-элементы-в-treeset-по-возрастанию)
|
||||
+ [Чем `LinkedHashSet` отличается от `HashSet`?](jcf.md#Чем-linkedhashset-отличается-от-hashset)
|
||||
+ [Для `Enum` есть специальный класс `java.util.EnumSet`. Зачем? Чем авторов не устраивал `HashSet` или `TreeSet`?](jcf.md#Для-enum-есть-специальный-класс-javautilenumset-Зачем-Чем-авторов-не-устраивал-hashset-или-treeset)
|
||||
+ [Какие существуют способы перебирать элементы списка?](jcf.md#Какие-существуют-способы-перебирать-элементы-списка)
|
||||
+ [Каким образом можно получить синхронизированные объекты стандартных коллекций?](jcf.md#Каким-образом-можно-получить-синхронизированные-объекты-стандартных-коллекций)
|
||||
+ [Как получить коллекцию только для чтения?](jcf.md#Как-получить-коллекцию-только-для-чтения)
|
||||
+ [Напишите однопоточную программу, которая заставляет коллекцию выбросить `ConcurrentModificationException`.](jcf.md#Напишите-однопоточную-программу-которая-заставляет-коллекцию-выбросить-concurrentmodificationexception)
|
||||
+ [Приведите пример, когда какая-либо коллекция выбрасывает `UnsupportedOperationException`.](jcf.md#Приведите-пример-когда-какая-либо-коллекция-выбрасывает-unsupportedoperationexception)
|
||||
+ [Реализуйте симметрическую разность двух коллекций используя методы `Collection` (`addAll(...)`, `removeAll(...)`, `retainAll(...)`).](jcf.md#Реализуйте-симметрическую-разность-двух-коллекций-используя-методы-collection-addall-removeall-retainall)
|
||||
+ [Как, используя LinkedHashMap, сделать кэш c «invalidation policy»?](jcf.md#Как-используя-linkedhashmap-сделать-кэш-c-invalidation-policy)
|
||||
+ [Как одной строчкой скопировать элементы любой `collection` в массив?](jcf.md#Как-одной-строчкой-скопировать-элементы-любой-collection-в-массив)
|
||||
+ [Как одним вызовом из `List` получить `List` со всеми элементами, кроме первых и последних 3-х?](jcf.md#Как-одним-вызовом-из-list-получить-list-со-всеми-элементами-кроме-первых-и-последних-3-х)
|
||||
+ [Как одной строчкой преобразовать `HashSet` в `ArrayList`?](jcf.md#Как-одной-строчкой-преобразовать-hashset-в-arraylist)
|
||||
+ [Как одной строчкой преобразовать `ArrayList` в `HashSet`?](jcf.md#Как-одной-строчкой-преобразовать-arraylist-в-hashset)
|
||||
+ [Сделайте `HashSet` из ключей `HashMap`.](jcf.md#Сделайте-hashset-из-ключей-hashmap)
|
||||
+ [Сделайте `HashMap` из `HashSet<Map.Entry<K, V>>`.](jcf.md#Сделайте-hashmap-из-hashsetmapentryk-v)
|
||||
|
||||
[к оглавлению](#Вопросы-для-собеседования-на-java-junior)
|
||||
|
||||
##Java 8
|
||||
+ [Какие нововведения, появились в Java 8 и JDK 8?](java8.md#Какие-нововведения-появились-в-java-8-и-jdk-8)
|
||||
+ [Что такое _«лямбда»_? Какова структура и особенности использования лямбда-выражения?](java8.md#Что-такое-лямбда-Какова-структура-и-особенности-использования-лямбда-выражения)
|
||||
+ [К каким переменным есть доступ у лямбда-выражений?](java8.md#К-каким-переменным-есть-доступ-у-лямбда-выражений)
|
||||
+ [Как отсортировать список строк с помощью лямбда-выражения?](java8.md#Как-отсортировать-список-строк-с-помощью-лямбда-выражения)
|
||||
+ [Что такое «ссылка на метод»?](java8.md#Что-такое-ссылка-на-метод)
|
||||
+ [Какие виды ссылок на методы вы знаете?](java8.md#Какие-виды-ссылок-на-методы-вы-знаете)
|
||||
+ [Объясните выражение `System.out::println`.](java8.md#Объясните-выражение-systemoutprintln)
|
||||
+ [Что такое «функциональные интерфейсы»?](java8.md#Что-такое-функциональные-интерфейсы)
|
||||
+ [Для чего нужны функциональные интерфейсы `Function<T,R>`, `DoubleFunction<R>`, `IntFunction<R>` и `LongFunction<R>`?](java8.md#Для-чего-нужны-функциональные-интерфейсы-functiontr-doublefunctionr-intfunctionr-и-longfunctionr)
|
||||
+ [Для чего нужны функциональные интерфейсы `UnaryOperator<T>`, `DoubleUnaryOperator`, `IntUnaryOperator` и `LongUnaryOperator`?](java8.md#Для-чего-нужны-функциональные-интерфейсы-unaryoperatort-doubleunaryoperator-intunaryoperator-и-longunaryoperator)
|
||||
+ [Для чего нужны функциональные интерфейсы `BinaryOperator<T>`, `DoubleBinaryOperator`, `IntBinaryOperator` и `LongBinaryOperator`?](java8.md#Для-чего-нужны-функциональные-интерфейсы-binaryoperatort-doublebinaryoperator-intbinaryoperator-и-longbinaryoperator)
|
||||
+ [Для чего нужны функциональные интерфейсы `Predicate<T>`, `DoublePredicate`, `IntPredicate` и `LongPredicate`?](java8.md#Для-чего-нужны-функциональные-интерфейсы-predicatet-doublepredicate-intpredicate-и-longpredicate)
|
||||
+ [Для чего нужны функциональные интерфейсы `Consumer<T>`, `DoubleConsumer`, `IntConsumer` и `LongConsumer`?](java8.md#Для-чего-нужны-функциональные-интерфейсы-consumert-doubleconsumer-intconsumer-и-longconsumer)
|
||||
+ [Для чего нужны функциональные интерфейсы `Supplier<T>`, `BooleanSupplier`, `DoubleSupplier`, `IntSupplier` и `LongSupplier`?](java8.md#Для-чего-нужны-функциональные-интерфейсы-suppliert--booleansupplier-doublesupplier-intsupplier-и-longsupplier)
|
||||
+ [Для чего нужен функциональный интерфейс `BiConsumer<T,U>`?](java8.md#Для-чего-нужен-функциональный-интерфейс-biconsumertu)
|
||||
+ [Для чего нужен функциональный интерфейс `BiFunction<T,U,R>`?](java8.md#Для-чего-нужен-функциональный-интерфейс-bifunctiontur)
|
||||
+ [Для чего нужен функциональный интерфейс `BiPredicate<T,U>`?](java8.md#Для-чего-нужен-функциональный-интерфейс-bipredicatetu)
|
||||
+ [Для чего нужны функциональные интерфейсы вида `_To_Function`?](java8.md#Для-чего-нужны-функциональные-интерфейсы-вида-tofunction)
|
||||
+ [Для чего нужны функциональные интерфейсы `ToDoubleBiFunction<T,U>`, `ToIntBiFunction<T,U>` и `ToLongBiFunction<T,U>`?](java8.md#Для-чего-нужны-функциональные-интерфейсы-todoublebifunctiontu-tointbifunctiontu-и-tolongbifunctiontu)
|
||||
+ [Для чего нужны функциональные интерфейсы `ToDoubleFunction<T>`, `ToIntFunction<T>` и `ToLongFunction<T>`?](java8.md#Для-чего-нужны-функциональные-интерфейсы-todoublefunctiont-tointfunctiont-и-tolongfunctiont)
|
||||
+ [Для чего нужны функциональные интерфейсы `ObjDoubleConsumer<T>`, `ObjIntConsumer<T>` и `ObjLongConsumer<T>`?](java8.md#Для-чего-нужны-функциональные-интерфейсы-objdoubleconsumert-objintconsumert-и-objlongconsumert)
|
||||
+ [Что такое `StringJoiner`?](java8.md#Что-такое-stringjoiner)
|
||||
+ [Что такое `default` методы интрефейса?](java8.md#Что-такое-default-методы-интрефейса)
|
||||
+ [Как вызывать `default` метод интерфейса в реализующем этот интерфейс классе?](java8.md#Как-вызывать-default-метод-интерфейса-в-реализующем-этот-интерфейс-классе)
|
||||
+ [Что такое `static` метод интерфейса?](java8.md#Что-такое-static-метод-интерфейса)
|
||||
+ [Как вызывать `static` метод интерфейса?](java8.md#Как-вызывать-static-метод-интерфейса)
|
||||
+ [Что такое `Optional`?](java8.md#Что-такое-optional)
|
||||
+ [Что такое `Stream`?](java8.md#Что-такое-stream)
|
||||
+ [Какие существуют способы создания стрима?](java8.md#Какие-существуют-способы-создания-стрима)
|
||||
+ [В чем разница между `Collection` и `Stream`?](java8.md#В-чем-разница-между-collection-и-stream)
|
||||
+ [Для чего нужен метод `collect()` в стримах?](java8.md#Для-чего-нужен-метод-collect-в-стримах)
|
||||
+ [Для чего в стримах применяются методы `forEach()` и `forEachOrdered()`?](java8.md#Для-чего-в-стримах-применяются-методы-foreach-и-foreachordered)
|
||||
+ [Для чего в стримах предназначены методы `map()` и `mapToInt()`, `mapToDouble()`, `mapToLong()`?](java8.md#Для-чего-в-стримах-предназначены-методы-map-и-maptoint-maptodouble-maptolong)
|
||||
+ [Какова цель метода `filter()` в стримах?](java8.md#Какова-цель-метода-filter-в-стримах)
|
||||
+ [Для чего в стримах предназначен метод `limit()`?](java8.md#Для-чего-в-стримах-предназначен-метод-limit)
|
||||
+ [Для чего в стримах предназначен метод `sorted()`?](java8.md#Для-чего-в-стримах-предназначен-метод-sorted)
|
||||
+ [Для чего в стримах предназначены методы `flatMap()`, `flatMapToInt()`, `flatMapToDouble()`, `flatMapToLong()`?](java8.md#Для-чего-в-стримах-предназначены-методы-flatmap-flatmaptoint-flatmaptodouble-flatmaptolong)
|
||||
+ [Расскажите о параллельной обработке в Java 8.](java8.md#Расскажите-о-параллельной-обработке-в-java-8)
|
||||
+ [Какие конечные методы работы со стримами вы знаете?](java8.md#Какие-конечные-методы-работы-со-стримами-вы-знаете)
|
||||
+ [Какие промежуточные методы работы со стримами вы знаете?](java8.md#Какие-промежуточные-методы-работы-со-стримами-вы-знаете)
|
||||
+ [Как вывести на экран 10 случайных чисел, используя `forEach()`?](java8.md#Как-вывести-на-экран-10-случайных-чисел-используя-foreach)
|
||||
+ [Как можно вывести на экран уникальные квадраты чисел используя метод `map()`?](java8.md#Как-можно-вывести-на-экран-уникальные-квадраты-чисел-используя-метод-map)
|
||||
+ [Как вывести на экран количество пустых строк с помощью метода `filter()`?](java8.md#Как-вывести-на-экран-количество-пустых-строк-с-помощью-метода-filter)
|
||||
+ [Как вывести на экран 10 случайных чисел в порядке возрастания?](java8.md#Как-вывести-на-экран-10-случайных-чисел-в-порядке-возрастания)
|
||||
+ [Как найти максимальное число в наборе?](java8.md#Как-найти-максимальное-число-в-наборе)
|
||||
+ [Как найти минимальное число в наборе?](java8.md#Как-найти-минимальное-число-в-наборе)
|
||||
+ [Как получить сумму всех чисел в наборе?](java8.md#Как-получить-сумму-всех-чисел-в-наборе)
|
||||
+ [Как получить среднее значение всех чисел?](java8.md#Как-получить-среднее-значение-всех-чисел)
|
||||
+ [Какие дополнительные методы для работы с ассоциативными массивами (maps) появились в Java 8?](java8.md#Какие-дополнительные-методы-для-работы-с-ассоциативными-массивами-maps-появились-в-java-8)
|
||||
+ [Что такое `LocalDateTime`?](java8.md#Что-такое-localdatetime)
|
||||
+ [Что такое `ZonedDateTime`?](java8.md#Что-такое-zoneddatetime)
|
||||
+ [Как получить текущую дату с использованием Date Time API из Java 8?](java8.md#Как-получить-текущую-дату-с-использованием-date-time-api-из-java-8)
|
||||
+ [Как добавить 1 неделю, 1 месяц, 1 год, 10 лет к текущей дате с использованием Date Time API?](java8.md#Как-добавить-1-неделю-1-месяц-1-год-10-лет-к-текущей-дате-с-использованием-date-time-api)
|
||||
+ [Как получить следующий вторник используя Date Time API?](java8.md#Как-получить-следующий-вторник-используя-date-time-api)
|
||||
+ [Как получить вторую субботу текущего месяца используя Date Time API?](java8.md#Как-получить-вторую-субботу-текущего-месяца-используя-date-time-api)
|
||||
+ [Как получить текущее время с точностью до миллисекунд используя Date Time API?](java8.md#Как-получить-текущее-время-с-точностью-до-миллисекунд-используя-date-time-api)
|
||||
+ [Как получить текущее время по местному времени с точностью до миллисекунд используя Date Time API?](java8.md#Как-получить-текущее-время-по-местному-времени-с-точностью-до-миллисекунд-используя-date-time-api)
|
||||
+ [Как определить повторяемую аннотацию?](java8.md#Как-определить-повторяемую-аннотацию)
|
||||
+ [Что такое `Nashorn`?](java8.md#Что-такое-nashorn)
|
||||
+ [Что такое `jjs`?](java8.md#Что-такое-jjs)
|
||||
+ [Какой класс появился в Java 8 для кодирования/декодирования данных?](java8.md#Какой-класс-появился-в-java-8-для-кодированиядекодирования-данных)
|
||||
+ [Как создать Base64 кодировщик и декодировщик?](java8.md#Как-создать-base64-кодировщик-и-декодировщик)
|
||||
|
||||
[к оглавлению](#Вопросы-для-собеседования-на-java-junior)
|
||||
|
||||
##Потоки ввода/вывода в Java
|
||||
+ [В чём заключается разница между IO и NIO?](io.md#В-чём-заключается-разница-между-io-и-nio)
|
||||
+ [Какие особенности NIO вы знаете?](io.md#Какие-особенности-nio-вы-знаете)
|
||||
+ [Что такое _«каналы»_?](io.md#Что-такое-каналы)
|
||||
+ [Какие существуют виды потоков ввода/вывода?](io.md#Какие-существуют-виды-потоков-вводавывода)
|
||||
+ [Назовите основные классы потоков ввода/вывода.](io.md#Назовите-основные-классы-потоков-вводавывода)
|
||||
+ [В каких пакетах расположены классы потоков ввода/вывода?](io.md#В-каких-пакетах-расположены-классы-потоков-вводавывода)
|
||||
+ [Какие подклассы класса `InputStream` вы знаете, для чего они предназначены?](io.md#Какие-подклассы-класса-inputstream-вы-знаете-для-чего-они-предназначены)
|
||||
+ [Для чего используется `PushbackInputStream`?](io.md#Для-чего-используется-pushbackinputstream)
|
||||
+ [Для чего используется `SequenceInputStream`?](io.md#Для-чего-используется-sequenceinputstream)
|
||||
+ [Какой класс позволяет читать данные из входного байтового потока в формате примитивных типов данных?](io.md#Какой-класс-позволяет-читать-данные-из-входного-байтового-потока-в-формате-примитивных-типов-данных)
|
||||
+ [Какие подклассы класса `OutputStream` вы знаете, для чего они предназначены?](io.md#Какие-подклассы-класса-outputstream-вы-знаете-для-чего-они-предназначены)
|
||||
+ [Какие подклассы класса `Reader` вы знаете, для чего они предназначены?](io.md#Какие-подклассы-класса-reader-вы-знаете-для-чего-они-предназначены)
|
||||
+ [Какие подклассы класса `Writer` вы знаете, для чего они предназначены?](io.md#Какие-подклассы-класса-writer-вы-знаете-для-чего-они-предназначены)
|
||||
+ [В чем отличие класса `PrintWriter` от `PrintStream`?](io.md#В-чем-отличие-класса-printwriter-от-printstream)
|
||||
+ [Чем отличаются и что общего у `InputStream`, `OutputStream`, `Reader`, `Writer`?](io.md#Чем-отличаются-и-что-общего-у-inputstream-outputstream-reader-writer)
|
||||
+ [Какие классы позволяют преобразовать байтовые потоки в символьные и обратно?](io.md#Какие-классы-позволяют-преобразовать-байтовые-потоки-в-символьные-и-обратно)
|
||||
+ [Какие классы позволяют ускорить чтение/запись за счет использования буфера?](io.md#Какие-классы-позволяют-ускорить-чтениезапись-за-счет-использования-буфера)
|
||||
+ [Какой класс предназначен для работы с элементами файловой системы?](io.md#Какой-класс-предназначен-для-работы-с-элементами-файловой-системы)
|
||||
+ [Какие методы класса `File` вы знаете?](io.md#Какие-методы-класса-file-вы-знаете)
|
||||
+ [Что вы знаете об интерфейсе `FileFilter`?](io.md#Что-вы-знаете-об-интерфейсе-filefilter)
|
||||
+ [Как выбрать все элементы определенного каталога по критерию (например, с определенным расширением)?](io.md#Как-выбрать-все-элементы-определенного-каталога-по-критерию-например-с-определенным-расширением)
|
||||
+ [Что вы знаете о `RandomAccessFile`?](io.md#Что-вы-знаете-о-randomaccessfile)
|
||||
+ [Какие режимы доступа к файлу есть у `RandomAccessFile`?](io.md#Какие-режимы-доступа-к-файлу-есть-у-randomaccessfile)
|
||||
+ [Какие классы поддерживают чтение и запись потоков в компрессированном формате?](io.md#Какие-классы-поддерживают-чтение-и-запись-потоков-в-компрессированном-формате)
|
||||
+ [Существует ли возможность перенаправить потоки стандартного ввода/вывода?](io.md#Существует-ли-возможность-перенаправить-потоки-стандартного-вводавывода)
|
||||
+ [Какой символ является разделителем при указании пути в файловой системе?](io.md#Какой-символ-является-разделителем-при-указании-пути-в-файловой-системе)
|
||||
+ [Что такое _«абсолютный путь»_ и _«относительный путь»_?](io.md#Что-такое-абсолютный-путь-и-относительный-путь)
|
||||
+ [Что такое _«символьная ссылка»_?](io.md#Что-такое-символьная-ссылка)
|
||||
|
||||
[к оглавлению](#Вопросы-для-собеседования-на-java-junior)
|
||||
|
||||
##Сериализация
|
||||
+ [Что такое _«сериализация»_?](serialization.md#Что-такое-сериализация)
|
||||
+ [Опишите процесс сериализации/десериализации с использованием `Serializable`.](serialization.md#Опишите-процесс-сериализациидесериализации-с-использованием-serializable)
|
||||
+ [Как изменить стандартное поведение сериализации/десериализации?](serialization.md#Как-изменить-стандартное-поведение-сериализациидесериализации)
|
||||
+ [Как исключить поля из сериализации?](serialization.md#Как-исключить-поля-из-сериализации)
|
||||
+ [Что обозначает ключевое слово `transient`?](serialization.md#Что-обозначает-ключевое-слово-transient)
|
||||
+ [Какое влияние оказывают на сериализуемость модификаторы полей `static` и `final`](serialization.md#Какое-влияние-оказывают-на-сериализуемость-модификаторы-полей-static-и-final)
|
||||
+ [Как не допустить сериализацию?](serialization.md#Как-не-допустить-сериализацию)
|
||||
+ [Как создать собственный протокол сериализации?](serialization.md#Как-создать-собственный-протокол-сериализации)
|
||||
+ [Какая роль поля `serialVersionUID` в сериализации?](serialization.md#Какая-роль-поля-serialversionuid-в-сериализации)
|
||||
+ [Когда стоит изменять значение поля `serialVersionUID`?](serialization.md#Когда-стоит-изменять-значение-поля-serialversionuid)
|
||||
+ [В чем проблема сериализации Singleton?](serialization.md#В-чем-проблема-сериализации-singleton)
|
||||
+ [Какие существуют способы контроля за значениями десериализованного объекта](serialization.md#Какие-существуют-способы-контроля-за-значениями-десериализованного-объекта)
|
||||
|
||||
[к оглавлению](#Вопросы-для-собеседования-на-java-junior)
|
||||
|
||||
##Многопоточность
|
||||
+ [Расскажите о модели памяти Java?](concurrency.md#Расскажите-о-модели-памяти-java)
|
||||
+ [Что такое «потокобезопасность»?](concurrency.md#Что-такое-потокобезопасность)
|
||||
+ [Что такое _«кооперативная многозадачность»_? Какой тип многозадачности использует Java? Чем обусловлен этот выбор?](concurrency.md#Что-такое-кооперативная-многозадачность-Какой-тип-многозадачности-использует-java-Чем-обусловлен-этот-выбор)
|
||||
+ [Что такое _ordering_, _as-if-serial semantics_, _sequential consistency_, _visibility_, _atomicity_, _happens-before_, _mutual exclusion_, _safe publication_?](concurrency.md#Что-такое-ordering-as-if-serial-semantics-sequential-consistency-visibility-atomicity-happens-before-mutual-exclusion-safe-publication)
|
||||
+ [Чем отличается процесс от потока?](concurrency.md#Чем-отличается-процесс-от-потока)
|
||||
+ [Что такое _«зелёные потоки»_ и есть ли они в Java?](concurrency.md#Что-такое-зелёные-потоки-и-есть-ли-они-в-java)
|
||||
+ [Каким образом можно создать поток?](concurrency.md#Каким-образом-можно-создать-поток)
|
||||
+ [Чем различаются `Thread` и `Runnable`?](concurrency.md#Чем-различаются-thread-и-runnable)
|
||||
+ [В чём заключается разница между методами `start()` и `run()`?](concurrency.md#В-чём-заключается-разница-между-методами-start-и-run)
|
||||
+ [Как принудительно запустить поток?](concurrency.md#Как-принудительно-запустить-поток)
|
||||
+ [Что такое _«монитор»_ в Java?](concurrency.md#Что-такое-монитор-в-java)
|
||||
+ [Дайте определение понятию «синхронизация».](concurrency.md#Дайте-определение-понятию-синхронизация)
|
||||
+ [Какие существуют способы синхронизации в Java?](concurrency.md#Какие-существуют-способы-синхронизации-в-java)
|
||||
+ [В каких состояниях может находиться поток?](concurrency.md#В-каких-состояниях-может-находиться-поток)
|
||||
+ [Можно ли создавать новые экземпляры класса, пока выполняется `static synchronized` метод?](concurrency.md#Можно-ли-создавать-новые-экземпляры-класса-пока-выполняется-static-synchronized-метод)
|
||||
+ [Зачем может быть нужен `private` мьютекс?](concurrency.md#Зачем-может-быть-нужен-private-мьютекс)
|
||||
+ [Как работают методы `wait()` и `notify()`/`notifyAll()`?](concurrency.md#Как-работают-методы-wait-и-notifynotifyall)
|
||||
+ [В чем разница между `notify()` и `notifyAll()`?](concurrency.md#В-чем-разница-между-notify-и-notifyall)
|
||||
+ [Почему методы `wait()` и `notify()` вызываются только в синхронизированном блоке?](concurrency.md#Почему-методы-wait-и-notify-вызываются-только-в-синхронизированном-блоке)
|
||||
+ [Чем отличается работа метода `wait()` с параметром и без параметра?](concurrency.md#Чем-отличается-работа-метода-wait-с-параметром-и-без-параметра)
|
||||
+ [Чем отличаются методы `Thread.sleep()` и `Thread.yield()`?](concurrency.md#Чем-отличаются-методы-threadsleep-и-threadyield)
|
||||
+ [Как работает метод `Thread.join()`?](concurrency.md#Как-работает-метод-threadjoin)
|
||||
+ [Что такое _deadlock_?](concurrency.md#Что-такое-deadlock)
|
||||
+ [Что такое _livelock_?](concurrency.md#Что-такое-livelock)
|
||||
+ [Как проверить, удерживает ли поток монитор определённого ресурса?](concurrency.md#Как-проверить-удерживает-ли-поток-монитор-определённого-ресурса)
|
||||
+ [На каком объекте происходит синхронизация при вызове `static synchronized` метода?](concurrency.md#На-каком-объекте-происходит-синхронизация-при-вызове-static-synchronized-метода)
|
||||
+ [Для чего используется ключевое слово `volatile`, `synchronized`, `transient`, `native`?](concurrency.md#Для-чего-используется-ключевое-слово-volatile-synchronized-transient-native)
|
||||
+ [В чём различия между `volatile` и _Atomic_ переменными?](concurrency.md#В-чём-различия-между-volatile-и-atomic-переменными)
|
||||
+ [ В чём заключаются различия между `java.util.concurrent.Atomic*.compareAndSwap()` и `java.util.concurrent.Atomic*.weakCompareAndSwap()`.](concurrency.md#-В-чём-заключаются-различия-между-javautilconcurrentatomiccompareandswap-и-javautilconcurrentatomicweakcompareandswap)
|
||||
+ [Что значит _«приоритет потока»_?](concurrency.md#Что-значит-приоритет-потока)
|
||||
+ [Что такое _«потоки-демоны»_?](concurrency.md#Что-такое-потоки-демоны)
|
||||
+ [Можно ли сделать основной поток программы демоном?](concurrency.md#Можно-ли-сделать-основной-поток-программы-демоном)
|
||||
+ [Что значит _«усыпить»_ поток?](concurrency.md#Что-значит-усыпить-поток)
|
||||
+ [Чем отличаются два интерфейса `Runnable` и `Callable`?](concurrency.md#Чем-отличаются-два-интерфейса-runnable-и-callable)
|
||||
+ [Что такое `FutureTask`?](concurrency.md#Что-такое-futuretask)
|
||||
+ [В чем заключаются различия между `CyclicBarrier` и `CountDownLatch`?](concurrency.md#В-чем-заключаются-различия-между-cyclicbarrier-и-countdownlatch)
|
||||
+ [Что такое _race condition_?](concurrency.md#Что-такое-race-condition)
|
||||
+ [Существует ли способ решения проблемы _race condition_?](concurrency.md#Существует-ли-способ-решения-проблемы-race-condition)
|
||||
+ [Как остановить поток?](concurrency.md#Как-остановить-поток)
|
||||
+ [Почему не рекомендуется использовать метод `Thread.stop()`?](concurrency.md#Почему-не-рекомендуется-использовать-метод-threadstop)
|
||||
+ [Что происходит, когда в потоке выбрасывается исключение?](concurrency.md#Что-происходит-когда-в-потоке-выбрасывается-исключение)
|
||||
+ [В чем разница между `interrupted()` и `isInterrupted()`?](concurrency.md#В-чем-разница-между-interrupted-и-isinterrupted)
|
||||
+ [Что такое _«пул потоков»_?](concurrency.md#Что-такое-пул-потоков)
|
||||
+ [Какого размера должен быть пул потоков?](concurrency.md#Какого-размера-должен-быть-пул-потоков)
|
||||
+ [Что будет, если очередь пула потоков уже заполнена, но подаётся новая задача?](concurrency.md#Что-будет-если-очередь-пула-потоков-уже-заполнена-но-подаётся-новая-задача)
|
||||
+ [В чём заключается различие между методами `submit()` и `execute()` у пула потоков?](concurrency.md#В-чём-заключается-различие-между-методами-submit-и-execute-у-пула-потоков)
|
||||
+ [В чем заключаются различия между cтеком (stack) и кучей (heap) с точки зрения многопоточности?](concurrency.md#В-чем-заключаются-различия-между-cтеком-stack-и-кучей-heap-с-точки-зрения-многопоточности)
|
||||
+ [Как поделиться данными между двумя потоками?](concurrency.md#Как-поделиться-данными-между-двумя-потоками)
|
||||
+ [Какой параметр запуска JVM используется для контроля размера стека потока?](concurrency.md#Какой-параметр-запуска-jvm-используется-для-контроля-размера-стека-потока)
|
||||
+ [Как получить дамп потока?](concurrency.md#Как-получить-дамп-потока)
|
||||
+ [Что такое _ThreadLocal-переменная_?](concurrency.md#Что-такое-threadlocal-переменная)
|
||||
+ [Назовите различия между `synchronized` и `ReentrantLock`?](concurrency.md#Назовите-различия-между-synchronized-и-reentrantlock)
|
||||
+ [Что такое `ReadWriteLock`?](concurrency.md#Что-такое-readwritelock)
|
||||
+ [Что такое _«блокирующий метод»_?](concurrency.md#Что-такое-блокирующий-метод)
|
||||
+ [Что такое _«фреймворк Fork/Join»_?](concurrency.md#Что-такое-фреймворк-forkjoin)
|
||||
+ [Что такое `Semaphore`?](concurrency.md#Что-такое-semaphore)
|
||||
+ [Что такое _double checked locking Singleton_?](concurrency.md#Что-такое-double-checked-locking-singleton)
|
||||
+ [Как создать потокобезопасный Singleton?](concurrency.md#Как-создать-потокобезопасный-singleton)
|
||||
+ [Чем полезны неизменяемые объекты?](concurrency.md#Чем-полезны-неизменяемые-объекты)
|
||||
+ [Что такое _busy spin_?](concurrency.md#Что-такое-busy-spin)
|
||||
+ [Перечислите принципы, которым вы следуете в многопоточном программировании?](concurrency.md#Перечислите-принципы-которым-вы-следуете-в-многопоточном-программировании)
|
||||
+ [Какое из следующих утверждений о потоках неверно?](concurrency.md#Какое-из-следующих-утверждений-о-потоках-неверно)
|
||||
+ [Даны 3 потока Т1, Т2 и Т3? Как реализовать выполнение в последовательности Т1, Т2, Т3?](concurrency.md#Даны-3-потока-Т1-Т2-и-Т3-Как-реализовать-выполнение-в-последовательности-Т1-Т2-Т3)
|
||||
+ [Напишите минимальный неблокирующий стек (всего два метода — `push()` и `pop()`).](concurrency.md#Напишите-минимальный-неблокирующий-стек-всего-два-метода--push-и-pop)
|
||||
+ [Напишите минимальный неблокирующий стек (всего два метода — `push()` и `pop()`) с использованием `Semaphore`.](concurrency.md#Напишите-минимальный-неблокирующий-стек-всего-два-метода--push-и-pop-с-использованием-semaphore)
|
||||
+ [Напишите минимальный неблокирующий ArrayList (всего четыре метода — `add()`, `get()`, `remove()`, `size()`).](concurrency.md#Напишите-минимальный-неблокирующий-arraylist-всего-четыре-метода--add-get-remove-size)
|
||||
+ [Напишите потокобезопасную реализацию класса с неблокирующим методом `BigInteger next()`, который возвращает элементы последовательности: `[1, 2, 4, 8, 16, ...]`.](concurrency.md#Напишите-потокобезопасную-реализацию-класса-с-неблокирующим-методом-biginteger-next-который-возвращает-элементы-последовательности-1-2-4-8-16-)
|
||||
+ [Напишите простейший многопоточный ограниченный буфер с использованием `synchronized`.](concurrency.md#Напишите-простейший-многопоточный-ограниченный-буфер-с-использованием-synchronized)
|
||||
+ [Напишите простейший многопоточный ограниченный буфер с использованием `ReentrantLock`.](concurrency.md#Напишите-простейший-многопоточный-ограниченный-буфер-с-использованием-reentrantlock)
|
||||
|
||||
[к оглавлению](#Вопросы-для-собеседования-на-java-junior)
|
||||
|
||||
##Servlets, JSP, JSTL
|
||||
+ [Что такое _«сервлет»_?](servlets.md#Что-такое-сервлет)
|
||||
+ [В чем заключаются преимущества технологии сервлетов над CGI (Common Gateway Interface)?](servlets.md#В-чем-заключаются-преимущества-технологии-сервлетов-над-cgi-common-gateway-interface)
|
||||
+ [Какова структура веб-проекта?](servlets.md#Какова-структура-веб-проекта)
|
||||
+ [Что такое _«контейнер сервлетов»_?](servlets.md#Что-такое-контейнер-сервлетов)
|
||||
+ [Как контейнер сервлетов управляет жизненным циклом сервлета, когда и какие методы вызываются?](servlets.md#Как-контейнер-сервлетов-управляет-жизненным-циклом-сервлета-когда-и-какие-методы-вызываются)
|
||||
+ [Что такое _«дескриптор развертывания»_?](servlets.md#Что-такое-дескриптор-развертывания)
|
||||
+ [Какие действия необходимо проделать при создании сервлетов?](servlets.md#Какие-действия-необходимо-проделать-при-создании-сервлетов)
|
||||
+ [В каком случае требуется переопределять метод `service()`?](servlets.md#В-каком-случае-требуется-переопределять-метод-service)
|
||||
+ [Есть ли смысл определять для сервлета конструктор? Каким образом лучше инициализировать данные?](servlets.md#Есть-ли-смысл-определять-для-сервлета-конструктор-Каким-образом-лучше-инициализировать-данные)
|
||||
+ [Почему необходимо переопределить только `init()` метод без аргументов?](servlets.md#Почему-необходимо-переопределить-только-init-метод-без-аргументов)
|
||||
+ [Какие наиболее распространенные задачи выполняются в контейнере сервлетов?](servlets.md#Какие-наиболее-распространенные-задачи-выполняются-в-контейнере-сервлетов)
|
||||
+ [Что вы знаете о _сервлетных фильтрах_?](servlets.md#Что-вы-знаете-о-сервлетных-фильтрах)
|
||||
+ [Зачем в сервлетах используются различные _listener_?](servlets.md#Зачем-в-сервлетах-используются-различные-listener)
|
||||
+ [Когда стоит использовать фильтры сервлетов, а когда слушателей?](servlets.md#Когда-стоит-использовать-фильтры-сервлетов-а-когда-слушателей)
|
||||
+ [Как реализовать запуск сервлета одновременно с запуском приложения?](servlets.md#Как-реализовать-запуск-сервлета-одновременно-с-запуском-приложения)
|
||||
+ [Как обработать в приложении исключения, выброшенные другим сервлетом?](servlets.md#Как-обработать-в-приложении-исключения-выброшенные-другим-сервлетом)
|
||||
+ [Что представляет собой `ServletConfig`?](servlets.md#Что-представляет-собой-servletconfig)
|
||||
+ [Что представляет собой `ServletContext`?](servlets.md#Что-представляет-собой-servletcontext)
|
||||
+ [В чем отличия `ServletContext` и `ServletConfig`?](servlets.md#В-чем-отличия-servletcontext-и-servletconfig)
|
||||
+ [Для чего нужен интерфейс `ServletResponse`?](servlets.md#Для-чего-нужен-интерфейс-servletresponse)
|
||||
+ [Для чего нужен интерфейс `ServletRequest`?](servlets.md#Для-чего-нужен-интерфейс-servletrequest)
|
||||
+ [Что такое `Request Dispatcher`?](servlets.md#Что-такое-request-dispatcher)
|
||||
+ [Как из одного сервлета вызвать другой сервлет?](servlets.md#Как-из-одного-сервлета-вызвать-другой-сервлет)
|
||||
+ [Чем отличается `sendRedirect()` от `forward()`?](servlets.md#Чем-отличается-sendredirect-от-forward)
|
||||
+ [Для чего используются атрибуты сервлетов и как происходит работа с ними?](servlets.md#Для-чего-используются-атрибуты-сервлетов-и-как-происходит-работа-с-ними)
|
||||
+ [Каким образом можно допустить в сервлете deadlock?](servlets.md#Каким-образом-можно-допустить-в-сервлете-deadlock)
|
||||
+ [Как получить реальное расположение сервлета на сервере?](servlets.md#Как-получить-реальное-расположение-сервлета-на-сервере)
|
||||
+ [Как получить информацию о сервере из сервлета?](servlets.md#Как-получить-информацию-о-сервере-из-сервлета)
|
||||
+ [Как получить IP адрес клиента на сервере?](servlets.md#Как-получить-ip-адрес-клиента-на-сервере)
|
||||
+ [Какие классы-обертки для сервлетов вы знаете?](servlets.md#Какие-классы-обертки-для-сервлетов-вы-знаете)
|
||||
+ [В чем отличия `GenericServlet` и `HttpServlet`?](servlets.md#В-чем-отличия-genericservlet-и-httpservlet)
|
||||
+ [Почему `HttpServlet` класс объявлен как абстрактный?](servlets.md#Почему-httpservlet-класс-объявлен-как-абстрактный)
|
||||
+ [Какие основные методы присутствуют в классе `HttpServlet`?](servlets.md#Какие-основные-методы-присутствуют-в-классе-httpservlet)
|
||||
+ [Стоит ли волноваться о многопоточной безопасности работая с сервлетами?](servlets.md#Стоит-ли-волноваться-о-многопоточной-безопасности-работая-с-сервлетами)
|
||||
+ [Какой метод HTTP не является неизменяемым?](servlets.md#Какой-метод-http-не-является-неизменяемым)
|
||||
+ [Какие есть методы отправки данных с клиента на сервер?](servlets.md#Какие-есть-методы-отправки-данных-с-клиента-на-сервер)
|
||||
+ [В чем разница между методами `GET` и `POST`?](servlets.md#В-чем-разница-между-методами-get-и-post)
|
||||
+ [В чем разница между `PrintWriter` и `ServletOutputStream`?](servlets.md#В-чем-разница-между-printwriter-и-servletoutputstream)
|
||||
+ [Можно ли одновременно использовать в сервлете `PrintWriter` и `ServletOutputStream`?](servlets.md#Можно-ли-одновременно-использовать-в-сервлете-printwriter-и-servletoutputstream)
|
||||
+ [Расскажите об интерфейсе `SingleThreadModel`.](servlets.md#Расскажите-об-интерфейсе-singlethreadmodel)
|
||||
+ [Что означает _URL encoding_? Как это осуществить в Java?](servlets.md#Что-означает-url-encoding-Как-это-осуществить-в-java)
|
||||
+ [Какие различные методы управления сессией в сервлетах вы знаете?](servlets.md#Какие-различные-методы-управления-сессией-в-сервлетах-вы-знаете)
|
||||
+ [Что такое _cookies_?](servlets.md#Что-такое-cookies)
|
||||
+ [Какие методы для работы с cookies предусмотрены в сервлетах?](servlets.md#Какие-методы-для-работы-с-cookies-предусмотрены-в-сервлетах)
|
||||
+ [Что такое _URL Rewriting_?](servlets.md#Что-такое-url-rewriting)
|
||||
+ [Зачем нужны и чем отличаются методы `encodeURL()` и `encodeRedirectURL()`?](servlets.md#Зачем-нужны-и-чем-отличаются-методы-encodeurl-и-encoderedirecturl)
|
||||
+ [Что такое _«сессия»_?](servlets.md#Что-такое-сессия)
|
||||
+ [Как уведомить объект в сессии, что сессия недействительна или закончилась?](servlets.md#Как-уведомить-объект-в-сессии-что-сессия-недействительна-или-закончилась)
|
||||
+ [Какой существует эффективный способ удостоверится, что все сервлеты доступны только для пользователя с верной сессией?](servlets.md#Какой-существует-эффективный-способ-удостоверится-что-все-сервлеты-доступны-только-для-пользователя-с-верной-сессией)
|
||||
+ [Как мы можем обеспечить _transport layer security_ для нашего веб приложения?](servlets.md#Как-мы-можем-обеспечить-transport-layer-security-для-нашего-веб-приложения)
|
||||
+ [Как организовать подключение к базе данных, обеспечить журналирование в сервлете?](servlets.md#Как-организовать-подключение-к-базе-данных-обеспечить-журналирование-в-сервлете)
|
||||
+ [Какие основные особенности появились в спецификации _Servlet 3_?](servlets.md#Какие-основные-особенности-появились-в-спецификации-servlet-3)
|
||||
+ [Какие способы аутентификации доступны сервлету?](servlets.md#Какие-способы-аутентификации-доступны-сервлету)
|
||||
+ [Что такое _Java Server Pages (JSP)_?](servlets.md#Что-такое-java-server-pages-jsp)
|
||||
+ [Зачем нужен JSP?](servlets.md#Зачем-нужен-jsp)
|
||||
+ [Опишите, как обрабатываются JSP страницы, начиная от запроса к серверу, заканчивая ответом пользователю.](servlets.md#Опишите-как-обрабатываются-jsp-страницы-начиная-от-запроса-к-серверу-заканчивая-ответом-пользователю)
|
||||
+ [Расскажите об этапах (фазах) жизненного цикла JSP.](servlets.md#Расскажите-об-этапах-фазах-жизненного-цикла-jsp)
|
||||
+ [Расскажите о методах жизненного цикла JSP.](servlets.md#Расскажите-о-методах-жизненного-цикла-jsp)
|
||||
+ [Какие методы жизненного цикла JSP могут быть переопределены?](servlets.md#Какие-методы-жизненного-цикла-jsp-могут-быть-переопределены)
|
||||
+ [Как можно предотвратить прямой доступ к JSP странице из браузера?](servlets.md#Как-можно-предотвратить-прямой-доступ-к-jsp-странице-из-браузера)
|
||||
+ [Какая разница между _динамическим_ и _статическим_ содержимым JSP?](servlets.md#Какая-разница-между-динамическим-и-статическим-содержимым-jsp)
|
||||
+ [Как закомментировать код в JSP?](servlets.md#Как-закомментировать-код-в-jsp)
|
||||
+ [Какие существуют основные типы тегов JSP?](servlets.md#Какие-существуют-основные-типы-тегов-jsp)
|
||||
+ [Что вы знаете о действиях JSP (_Action tag_ и _JSP Action Elements_).](servlets.md#Что-вы-знаете-о-действиях-jsp-action-tag-и-jsp-action-elements)
|
||||
+ [Взаимодействие _JSP - сервлет - JSP_.](servlets.md#Взаимодействие-jsp---сервлет---jsp)
|
||||
+ [Какие области видимости переменных существуют в JSP?](servlets.md#Какие-области-видимости-переменных-существуют-в-jsp)
|
||||
+ [Какие неявные, внутренние объекты и методы есть на JSP странице?](servlets.md#Какие-неявные-внутренние-объекты-и-методы-есть-на-jsp-странице)
|
||||
+ [Какие неявные объекты не доступны в обычной JSP странице?](servlets.md#Какие-неявные-объекты-не-доступны-в-обычной-jsp-странице)
|
||||
+ [Что вы знаете о `PageContext` и какие преимущества его использования?](servlets.md#Что-вы-знаете-о-pagecontext-и-какие-преимущества-его-использования)
|
||||
+ [Как сконфигурировать параметры инициализации для JSP?](servlets.md#Как-сконфигурировать-параметры-инициализации-для-jsp)
|
||||
+ [Почему не рекомендуется использовать скриплеты (скриптовые элементы) в JSP?](servlets.md#Почему-не-рекомендуется-использовать-скриплеты-скриптовые-элементы-в-jsp)
|
||||
+ [Можно ли определить класс внутри JSP страницы?](servlets.md#Можно-ли-определить-класс-внутри-jsp-страницы)
|
||||
+ [Что вы знаете о Языке выражений JSP (JSP Expression Language – EL)?](servlets.md#Что-вы-знаете-о-Языке-выражений-jsp-jsp-expression-language--el)
|
||||
+ [Какие типы EL операторов вы знаете?](servlets.md#Какие-типы-el-операторов-вы-знаете)
|
||||
+ [Назовите неявные, внутренние объекты JSP EL и их отличия от объектов JSP.](servlets.md#Назовите-неявные-внутренние-объекты-jsp-el-и-их-отличия-от-объектов-jsp)
|
||||
+ [Как отключить возможность использования EL в JSP?](servlets.md#Как-отключить-возможность-использования-el-в-jsp)
|
||||
+ [Как узнать тип HTTP метода используя JSP EL?](servlets.md#Как-узнать-тип-http-метода-используя-jsp-el)
|
||||
+ [Что такое _JSTL (JSP Standard tag library)_?](servlets.md#Что-такое-jstl-jsp-standard-tag-library)
|
||||
+ [Из каких групп тегов состоит библиотека _JSTL_?](servlets.md#Из-каких-групп-тегов-состоит-библиотека-jstl)
|
||||
+ [Какая разница между `<c:set>` и `<jsp:useBean>`?](servlets.md#Какая-разница-между-cset-и-jspusebean)
|
||||
+ [Чем отличается `<c:import>` от `<jsp:include>` и директивы `<%@include %>`?](servlets.md#Чем-отличается-cimport-от-jspinclude-и-директивы-include-)
|
||||
+ [Как можно расширить функциональность JSP?](servlets.md#Как-можно-расширить-функциональность-jsp)
|
||||
+ [Что вы знаете о написании пользовательских JSP тегов?](servlets.md#Что-вы-знаете-о-написании-пользовательских-jsp-тегов)
|
||||
+ [Приведите пример использования собственных тегов.](servlets.md#Приведите-пример-использования-собственных-тегов)
|
||||
+ [Как сделать перенос строки в HTML средствами JSP?](servlets.md#Как-сделать-перенос-строки-в-html-средствами-jsp)
|
||||
+ [Почему не нужно конфигурировать стандартные JSP теги в `web.xml`?](servlets.md#Почему-не-нужно-конфигурировать-стандартные-jsp-теги-в-webxml)
|
||||
+ [Как можно обработать ошибки JSP страниц?](servlets.md#Как-можно-обработать-ошибки-jsp-страниц)
|
||||
+ [Как происходит обработка ошибок с помощью JSTL?](servlets.md#Как-происходит-обработка-ошибок-с-помощью-jstl)
|
||||
+ [Как конфигурируется JSP в дескрипторе развертывания.](servlets.md#Как-конфигурируется-jsp-в-дескрипторе-развертывания)
|
||||
+ [Можно ли использовать Javascript на JSP странице?](servlets.md#Можно-ли-использовать-javascript-на-jsp-странице)
|
||||
+ [Всегда ли создается объект сессии на JSP странице, можно ли отключить его создание?](servlets.md#Всегда-ли-создается-объект-сессии-на-jsp-странице-можно-ли-отключить-его-создание)
|
||||
+ [Какая разница между `JSPWriter` и сервлетным `PrintWriter`?](servlets.md#Какая-разница-между-jspwriter-и-сервлетным-printwriter)
|
||||
+ [Опишите общие практические принципы работы с JSP.](servlets.md#Опишите-общие-практические-принципы-работы-с-jsp)
|
||||
|
||||
[к оглавлению](#Вопросы-для-собеседования-на-java-junior)
|
||||
|
||||
##Базы данных
|
||||
+ [Что такое _«база данных»_?](db.md#Что-такое-база-данных)
|
||||
+ [Что такое _«система управления базами данных»_?](db.md#Что-такое-система-управления-базами-данных)
|
||||
+ [Что такое _«реляционная модель данных»_?](db.md#Что-такое-реляционная-модель-данных)
|
||||
+ [Дайте определение терминам _«простой»_, _«составной» (composite)_, _«потенциальный» (candidate)_ и _«альтернативный» (alternate)_ ключ.](db.md#Дайте-определение-терминам-простой-составной-composite-потенциальный-candidate-и-альтернативный-alternate-ключ)
|
||||
+ [Что такое _«первичный ключ» (primary key)_? Каковы критерии его выбора?](db.md#Что-такое-первичный-ключ-primary-key-Каковы-критерии-его-выбора)
|
||||
+ [Что такое _«внешний ключ» (foreign key)_?](db.md#Что-такое-внешний-ключ-foreign-key)
|
||||
+ [Что такое _«нормализация»_?](db.md#Что-такое-нормализация)
|
||||
+ [Какие существуют нормальные формы?](db.md#Какие-существуют-нормальные-формы)
|
||||
+ [Что такое _«денормализация»_? Для чего она применяется?](db.md#Что-такое-денормализация-Для-чего-она-применяется)
|
||||
+ [Какие существуют типы связей в базе данных? Приведите примеры.](db.md#Какие-существуют-типы-связей-в-базе-данных-Приведите-примеры)
|
||||
+ [Что такое _«индексы»_? Для чего их используют? В чём заключаются их преимущества и недостатки?](db.md#Что-такое-индексы-Для-чего-их-используют-В-чём-заключаются-их-преимущества-и-недостатки)
|
||||
+ [Какие типы индексов существуют?](#Какие-типы-индексов-существуют)
|
||||
+ [В чем отличие между кластерными и некластерными индексами?](db.md#В-чем-отличие-между-кластерными-и-некластерными-индексами)
|
||||
+ [Имеет ли смысл индексировать данные, имеющие небольшое количество возможных значений?](db.md#Имеет-ли-смысл-индексировать-данные-имеющие-небольшое-количество-возможных-значений)
|
||||
+ [Когда полное сканирование набора данных выгоднее доступа по индексу?](db.md#Когда-полное-сканирование-набора-данных-выгоднее-доступа-по-индексу)
|
||||
+ [Что такое _«транзакция»_?](db.md#Что-такое-транзакция)
|
||||
+ [Назовите основные свойства транзакции.](db.md#Назовите-основные-свойства-транзакции)
|
||||
+ [Какие существуют уровни изолированности транзакций?](db.md#Какие-существуют-уровни-изолированности-транзакций)
|
||||
+ [Какие проблемы могут возникать при параллельном доступе с использованием транзакций?](db.md#Какие-проблемы-могут-возникать-при-параллельном-доступе-с-использованием-транзакций)
|
||||
|
||||
[к оглавлению](#Вопросы-для-собеседования-на-java-junior)
|
||||
|
||||
##SQL
|
||||
+ [Что такое _«SQL»_?](sql.md#Что-такое-sql)
|
||||
+ [Какие существуют операторы SQL?](sql.md#Какие-существуют-операторы-sql)
|
||||
+ [Что означает `NULL` в SQL?](sql.md#Что-означает-null-в-sql)
|
||||
+ [Что такое _«временная таблица»_? Для чего она используется?](sql.md#Что-такое-временная-таблица-Для-чего-она-используется)
|
||||
+ [Что такое _«представление» (view)_ и для чего оно применяется?](sql.md#Что-такое-представление-view-и-для-чего-оно-применяется)
|
||||
+ [Каков общий синтаксис оператора `SELECT`?](sql.md#Каков-общий-синтаксис-оператора-select)
|
||||
+ [Что такое `JOIN`?](sql.md#Что-такое-join)
|
||||
+ [Какие существуют типы `JOIN`?](sql.md#Какие-существуют-типы-join)
|
||||
+ [Что лучше использовать `JOIN` или подзапросы?](sql.md#Что-лучше-использовать-join-или-подзапросы)
|
||||
+ [Для чего используется оператор `HAVING`?](sql.md#Для-чего-используется-оператор-having)
|
||||
+ [В чем различие между операторами `HAVING` и `WHERE`?](sql.md#В-чем-различие-между-операторами-having-и-where)
|
||||
+ [Для чего используется оператор `ORDER BY`?](sql.md#Для-чего-используется-оператор-order-by)
|
||||
+ [Для чего используется оператор `GROUP BY`?](sql.md#Для-чего-используется-оператор-group-by)
|
||||
+ [Как `GROUP BY` обрабатывает значение `NULL`?](sql.md#Как-group-by-обрабатывает-значение-null)
|
||||
+ [В чем разница между операторами `GROUP BY` и `DISTINCT`?](sql.md#В-чем-разница-между-операторами-group-by-и-distinct)
|
||||
+ [Перечислите основные агрегатные функции.](sql.md#Перечислите-основные-агрегатные-функции)
|
||||
+ [В чем разница между `COUNT(*)` и `COUNT({column})`?](sql.md#В-чем-разница-между-count-и-countcolumn)
|
||||
+ [Что делает оператор `EXISTS`?](sql.md#Что-делает-оператор-exists)
|
||||
+ [Для чего используются операторы `IN`, `BETWEEN`, `LIKE`?](sql.md#Для-чего-используются-операторы-in-between-like)
|
||||
+ [Для чего применяется ключевое слово `UNION`?](sql.md#Для-чего-применяется-ключевое-слово-union)
|
||||
+ [Какие ограничения на целостность данных существуют в SQL?](sql.md#Какие-ограничения-на-целостность-данных-существуют-в-sql)
|
||||
+ [Какие отличия между ограничениями `PRIMARY` и `UNIQUE`?](sql.md#Какие-отличия-между-ограничениями-primary-и-unique)
|
||||
+ [Может ли значение в столбце, на который наложено ограничение `FOREIGN KEY`, равняться `NULL`?](sql.md#Может-ли-значение-в-столбце-на-который-наложено-ограничение-foreign-key-равняться-null)
|
||||
+ [Как создать индекс?](sql.md#Как-создать-индекс)
|
||||
+ [Что делает оператор `MERGE`?](sql.md#Что-делает-оператор-merge)
|
||||
+ [В чем отличие между операторами `DELETE` и `TRUNCATE`?](sql.md#В-чем-отличие-между-операторами-delete-и-truncate)
|
||||
+ [Что такое _«хранимая процедура»_?](sql.md#Что-такое-хранимая-процедура)
|
||||
+ [Что такое _«триггер»_?](sql.md#Что-такое-триггер)
|
||||
+ [Что такое _«курсор»_?](sql.md#Что-такое-курсор)
|
||||
+ [Опишите разницу типов данных `DATETIME` и `TIMESTAMP`.](sql.md#Опишите-разницу-типов-данных-datetime-и-timestamp)
|
||||
+ [Для каких числовых типов недопустимо использовать операции сложения/вычитания?](sql.md#Для-каких-числовых-типов-недопустимо-использовать-операции-сложениявычитания)
|
||||
+ [Какое назначение у операторов `PIVOT` и `UNPIVOT` в Transact-SQL?](sql.md#Какое-назначение-у-операторов-pivot-и-unpivot-в-transact-sql)
|
||||
+ [Расскажите об основных функциях ранжирования в Transact-SQL.](sql.md#Расскажите-об-основных-функциях-ранжирования-в-transact-sql)
|
||||
+ [Для чего используются операторы `INTERSECT`, `EXCEPT` в Transact-SQL?](sql.md#Для-чего-используются-операторы-intersect-except-в-transact-sql)
|
||||
+ [Напишите запрос...](sql.md#Напишите-запрос)
|
||||
|
||||
[к оглавлению](#Вопросы-для-собеседования-на-java-junior)
|
||||
|
||||
##JDBC
|
||||
+ [Что такое _JDBC_?](jdbc.md#Что-такое-jdbc)
|
||||
+ [В чем заключаются преимущества использования JDBC?](jdbc.md#В-чем-заключаются-преимущества-использования-jdbc)
|
||||
+ [Что из себя представляет JDBC URL?](jdbc.md#Что-из-себя-представляет-jdbc-url)
|
||||
+ [Из каких частей стоит JDBC?](jdbc.md#Из-каких-частей-стоит-jdbc)
|
||||
+ [Перечислите основные типы данных используемые в JDBC. Как они связаны с типами Java?](jdbc.md#Перечислите-основные-классы-и-интерфейсы-jdbc)
|
||||
+ [Опишите основные этапы работы с базой данных с использованием JDBC.](jdbc.md#Опишите-основные-этапы-работы-с-базой-данных-при-использовании-jdbc)
|
||||
+ [Как зарегистрировать драйвер JDBC?](jdbc.md#Как-зарегистрировать-драйвер-jdbc)
|
||||
+ [Как установить соединение с базой данных?](jdbc.md#Как-установить-соединение-с-базой-данных)
|
||||
+ [Какие уровни изоляции транзакций поддерживаются в JDBC?](jdbc.md#Какие-уровни-изоляции-транзакций-поддерживаются-в-jdbc)
|
||||
+ [При помощи чего формируются запросы к базе данных?](jdbc.md#При-помощи-чего-формируются-запросы-к-базе-данных)
|
||||
+ [Чем отличается Statement от PreparedStatement?](jdbc.md#Чем-отличается-statement-от-preparedstatement)
|
||||
+ [Как осуществляется запрос к базе данных и обработка результатов?](jdbc.md#Как-осуществляется-запрос-к-базе-данных-и-обработка-результатов)
|
||||
+ [Как вызвать хранимую процедуру?](jdbc.md#Как-вызвать-хранимую-процедуру)
|
||||
+ [Как закрыть соединение с базой данных?](jdbc.md#Как-закрыть-соединение-с-базой-данных)
|
||||
|
||||
[к оглавлению](#Вопросы-для-собеседования-на-java-junior)
|
||||
|
||||
##Тестирование
|
||||
+ [Что такое _«модульное тестирование»_?](test.md#Что-такое-модульное-тестирование)
|
||||
+ [Что такое _«интеграционное тестирование»_?](test.md#Что-такое-интеграционное-тестирование)
|
||||
+ [Чем интеграционное тестирование отличается от модульного?](test.md#Чем-интеграционное-тестирование-отличается-от-модульного)
|
||||
+ [Какие существуют виды тестовых объектов?](test.md#Какие-существуют-виды-тестовых-объектов)
|
||||
+ [Чем _stub_ отличается от _mock_?](test.md#Чем-stub-отличается-от-mock)
|
||||
+ [Что такое _«фикстуры»_?](test.md#Что-такое-фикстуры)
|
||||
+ [Какие аннотации фикстур существуют в JUnit?](test.md#Какие-аннотации-фикстур-существуют-в-junit)
|
||||
+ [Для чего в JUnit используется аннотация `@Ignore`?](test.md#Для-чего-в-junit-используется-аннотация-ignore)
|
||||
|
||||
[к оглавлению](#Вопросы-для-собеседования-на-java-junior)
|
||||
|
||||
##Журналирование
|
||||
+ [Какие существуют типы логов?](log.md#Какие-существуют-типы-логов)
|
||||
+ [Из каких частей состоит система журналирования log4j?](log.md#Из-каких-частей-состоит-система-журналирования-log4j)
|
||||
+ [Что такое _Logger_ в log4j?](log.md#Что-такое-logger-в-log4j)
|
||||
+ [Что такое _Appender_ в log4j?](log.md#Что-такое-appender-в-log4j)
|
||||
+ [Что такое _Layout_ в log4j?](log.md#Что-такое-layout-в-log4j)
|
||||
+ [Перечислите уровни журналирования в log4j? Назовите порядок их приоритетности.](log.md#Перечислите-уровни-журналирования-в-log4j-Назовите-порядок-их-приоритетности)
|
||||
+ [Какие существуют способы конфигурирования log4j?](log.md#Какие-существуют-способы-конфигурирования-log4j)
|
||||
|
||||
[к оглавлению](#Вопросы-для-собеседования-на-java-junior)
|
||||
|
||||
##UML
|
||||
+ [Что такое _UML_?](uml.md#Что-такое-uml)
|
||||
+ [Что такое _«диаграмма»_, _«нотация»_ и _«метамодель»_ в UML?](uml.md#Что-такое-диаграмма-нотация-и-метамодель-в-uml)
|
||||
+ [Какие существуют типы диаграмм?](uml.md#Какие-существуют-типы-диаграмм)
|
||||
+ [Какие виды отношений существуют в структурной диаграмме классов?](uml.md#Какие-виды-отношений-существуют-в-структурной-диаграмме-классов)
|
||||
|
||||
[к оглавлению](#Вопросы-для-собеседования-на-java-junior)
|
||||
|
||||
##XML
|
||||
+ [Что такое _XML_?](xml.md#Что-такое-xml)
|
||||
+ [Что такое _DTD_?](xml.md#Что-такое-dtd)
|
||||
+ [Чем _well-formed XML_ отличается от _valid XML_?](xml.md#Чем-well-formed-xml-отличается-от-valid-xml)
|
||||
+ [Что такое «_пространство имен_» в XML?](xml.md#Что-такое-пространство-имен-в-xml)
|
||||
+ [Что такое XSD? В чём его преимущества перед XML DTD?](xml.md#Что-такое-xsd-В-чём-его-преимущества-перед-xml-dtd)
|
||||
+ [Какие типы существуют в XSD?](xml.md#Какие-типы-существуют-в-xsd)
|
||||
+ [Какие вы знаете методы чтения XML? Опишите сильные и слабые стороны каждого метода.](xml.md#Какие-вы-знаете-методы-чтения-xml-Опишите-сильные-и-слабые-стороны-каждого-метода)
|
||||
+ [Когда следует использовать _DOM_, а когда _SAX_, _StAX_ анализаторы?](xml.md#Когда-следует-использовать-dom-а-когда-sax-stax-анализаторы)?
|
||||
+ [Какие вы знаете способы записи XML?](xml.md#Какие-вы-знаете-способы-записи-xml)
|
||||
+ [Что такое _JAXP_?](xml.md#Что-такое-jaxp)
|
||||
+ [Что такое _XSLT_?](xml.md#Что-такое-xslt)
|
||||
|
||||
[к оглавлению](#Вопросы-для-собеседования-на-java-junior)
|
||||
|
||||
##Шаблоны проектирования
|
||||
+ [Что такое _«шаблон проектирования»_?](patterns.md#Что-такое-шаблон-проектирования)
|
||||
+ [Назовите основные характеристики шаблонов.](patterns.md#Назовите-основные-характеристики-шаблонов)
|
||||
+ [Типы шаблонов проектирования.](patterns.md#Типы-шаблонов-проектирования)
|
||||
+ [Приведите примеры основных шаблонов проектирования.](patterns.md#Приведите-примеры-основных-шаблонов-проектирования)
|
||||
+ [Приведите примеры порождающих шаблонов проектирования.](patterns.md#Приведите-примеры-порождающих-шаблонов-проектирования)
|
||||
+ [Приведите примеры структурных шаблонов проектирования.](patterns.md#Приведите-примеры-структурных-шаблонов-проектирования)
|
||||
+ [Приведите примеры поведенческих шаблонов проектирования.](patterns.md#Приведите-примеры-поведенческих-шаблонов-проектирования)
|
||||
+ [Что такое _«антипаттерн»_? Какие антипаттерны вы знаете?](patterns.md#Что-такое-антипаттерн-Какие-антипаттерны-вы-знаете)
|
||||
+ [Что такое _Dependency Injection_?](patterns.md#Что-такое-dependency-injection)
|
||||
|
||||
[к оглавлению](#Вопросы-для-собеседования-на-java-junior)
|
||||
|
||||
##Основы HTML
|
||||
+ [Что такое _«HTML»_?](html.md#Что-такое-html)
|
||||
+ [Что такое _«XHTML»_?](html.md#Что-такое-xhtml)
|
||||
+ [Что такое `DOCTYPE` и зачем он нужен?](html.md#Что-такое-doctype-и-зачем-он-нужен)
|
||||
+ [Для чего предназначен тег `<head>`?](html.md#Для-чего-предназначен-тег-head)
|
||||
+ [Чем отличается `<div>` от `<span>`?](html.md#Чем-отличается-div-от-span)
|
||||
+ [Как обозначаются комментарии в HTML?](html.md#Как-обозначаются-комментарии-в-html)
|
||||
+ [Каким образом задаётся адрес документа, на который следует перейти?](html.md#Каким-образом-задаётся-адрес-документа-на-который-следует-перейти)
|
||||
+ [Как сделать ссылку на адрес электронной почты?](html.md#Как-сделать-ссылку-на-адрес-электронной-почты)
|
||||
+ [Для чего предназначен тег `<em>`?](html.md#Для-чего-предназначен-тег-em)
|
||||
+ [Для чего предназначены теги `<ol>`, `<ul>`, `<li>`?](html.md#Для-чего-предназначены-теги-ol-ul-li)
|
||||
+ [Для чего предназначены теги `<dl>`, `<dt>`, `<dd>`?](html.md#Для-чего-предназначены-теги-dl-dt-dd)
|
||||
+ [Для чего предназначены теги `<tr>`, `<th>`, `<td>`?](html.md#Для-чего-предназначены-теги-tr-th-td)
|
||||
+ [Обязательно ли писать атрибут `alt` в теге `<img>`?](html.md#Обязательно-ли-писать-атрибут-alt-в-теге-img)
|
||||
+ [В каком регистре лучше писать HTML-код?](html.md#В-каком-регистре-лучше-писать-html-код)
|
||||
+ [Что такое «мнемоника (entity)»?](html.md#Что-такое-мнемоника-entity)
|
||||
|
||||
[к оглавлению](#Вопросы-для-собеседования-на-java-junior)
|
||||
|
||||
##Основы CSS
|
||||
+ [Что такое _«CSS»_?](css.md#Что-такое-css)
|
||||
+ [Как в CSS обозначаются комментарии?](css.md#Как-в-css-обозначаются-комментарии)
|
||||
+ [Что такое _«селектор»_?](css.md#Что-такое-селектор)
|
||||
+ [Перечислите основные виды селекторов.](css.md#Перечислите-основные-виды-селекторов)
|
||||
+ [Что такое псевдокласс?](css.md#Что-такое-псевдокласс)
|
||||
+ [Какие существуют селекторы аттрибутов?](css.md#Какие-существуют-селекторы-аттрибутов)
|
||||
+ [В чем разница между `#my` и `.my`?](css.md#В-чем-разница-между-my-и-my)
|
||||
+ [В чем разница между `margin` и `padding`?](css.md#В-чем-разница-между-margin-и-padding)
|
||||
+ [В чем заключается разница между значениями `0` и `auto` в свойстве `margin`?](css.md#В-чем-заключается-разница-между-значениями-0-и-auto-в-свойстве-margin)
|
||||
+ [Какое свойство задает цвет фона?](css.md#Какое-свойство-задает-цвет-фона)
|
||||
+ [Как убрать подчеркивание для всех ссылок на странице?](css.md#Как-убрать-подчеркивание-для-всех-ссылок-на-странице)
|
||||
+ [Для чего используется свойство `clear`?](css.md#Для-чего-используется-свойство-clear)
|
||||
+ [Как сделать жирным текст во всех элементах `<p>`?](css.md#Как-сделать-жирным-текст-во-всех-элементах-p)
|
||||
+ [Как задать красный цвет для всех элементов, имеющих класс `red`?](css.md#Как-задать-красный-цвет-для-всех-элементов-имеющих-класс-red)
|
||||
|
||||
[к оглавлению](#Вопросы-для-собеседования-на-java-junior)
|
||||
|
||||
##Основы WEB
|
||||
+ [Что такое _WWW_?](web.md#Что-такое-www)
|
||||
+ [Что такое _W3C_?](web.md#Что-такое-w3c)
|
||||
+ [Какие существуют уровни модели _OSI_?](web.md#Какие-существуют-уровни-модели-osi)
|
||||
+ [Что такое _TCP/IP_?](web.md#Что-такое-tcpip)
|
||||
+ [Что такое _UDP_?](web.md#Что-такое-udp)
|
||||
+ [Чем отличаются _TCP_ и _UDP_?](web.md#Чем-отличаются-tcp-и-udp)
|
||||
+ [Что такое протокол передачи данных? Какие протоколы вы знаете?](web.md#Что-такое-протокол-передачи-данных-Какие-протоколы-вы-знаете)
|
||||
+ [Что такое _HTTP_ и _HTTPS_? Чем они отличаются?](web.md#Что-такое-http-и-https-Чем-они-отличаются)
|
||||
+ [Что такое _FTP_?](web.md#Что-такое-ftp)
|
||||
+ [Чем отличаются методы _GET_ и _POST_?](web.md#Чем-отличаются-методы-get-и-post)
|
||||
+ [Что такое _MIME тип_?](web.md#Что-такое-mime-тип)
|
||||
+ [Что такое _Web server_?](web.md#Что-такое-web-server)
|
||||
+ [Что такое _Web application_?](web.md#Что-такое-web-application)
|
||||
+ [Что такое _Application server_?](web.md#Что-такое-application-server)
|
||||
+ [Чем отличаются _Web server_ и _Application server_?](web.md#Чем-отличаются-web-server-и-application-server)
|
||||
+ [Что такое _AJAX_? Как принципиально устроена эта технология?](web.md#Что-такое-ajax-Как-принципиально-устроена-эта-технология)
|
||||
+ [Что такое _WebSocket_?](web.md#Что-такое-websocket)
|
||||
+ [Что такое _JSON_?](web.md#Что-такое-json)
|
||||
+ [Что такое _JSON схема_?](web.md#Что-такое-json-схема)
|
||||
+ [Что такое _cookies_?](web.md#Что-такое-cookies)
|
||||
+ [Что такое _«сессия»_?](web.md#Что-такое-сессия)
|
||||
+ [Что такое _«авторизация»_ и _«аутентификация»_? Чем они отличаются?](web.md#Что-такое-авторизация-и-аутентификация-Чем-они-отличаются)
|
||||
|
||||
[к оглавлению](#Вопросы-для-собеседования-на-java-junior)
|
||||
|
||||
##Источники
|
||||
+ [Вопросы на собеседование Junior Java Developer](https://jsehelper.blogspot.ru)
|
||||
Binary file not shown.
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,153 @@
|
|||
[Вопросы для собеседования на Java Junior](README.md)
|
||||
|
||||
#Основы CSS
|
||||
+ [Что такое _«CSS»_?](#Что-такое-css)
|
||||
+ [Как в CSS обозначаются комментарии?](#Как-в-css-обозначаются-комментарии)
|
||||
+ [Что такое _«селектор»_?](#Что-такое-селектор)
|
||||
+ [Перечислите основные виды селекторов.](#Перечислите-основные-виды-селекторов)
|
||||
+ [Что такое псевдокласс?](#Что-такое-псевдокласс)
|
||||
+ [Какие существуют селекторы аттрибутов?](#Какие-существуют-селекторы-аттрибутов)
|
||||
+ [В чем разница между `#my` и `.my`?](#В-чем-разница-между-my-и-my)
|
||||
+ [В чем разница между `margin` и `padding`?](#В-чем-разница-между-margin-и-padding)
|
||||
+ [В чем заключается разница между значениями `0` и `auto` в свойстве `margin`?](#В-чем-заключается-разница-между-значениями-0-и-auto-в-свойстве-margin)
|
||||
+ [Какое свойство задает цвет фона?](#Какое-свойство-задает-цвет-фона)
|
||||
+ [Как убрать подчеркивание для всех ссылок на странице?](#Как-убрать-подчеркивание-для-всех-ссылок-на-странице)
|
||||
+ [Для чего используется свойство `clear`?](#Для-чего-используется-свойство-clear)
|
||||
+ [Как сделать жирным текст во всех элементах `<p>`?](#Как-сделать-жирным-текст-во-всех-элементах-p)
|
||||
+ [Как задать красный цвет для всех элементов, имеющих класс `red`?](#Как-задать-красный-цвет-для-всех-элементов-имеющих-класс-red)
|
||||
|
||||
##Что такое _«CSS»_?
|
||||
__CSS, Cascading Style Sheets (каскадные таблицы стилей)__ - формальный язык описания внешнего вида документа, написанного с использованием языка разметки, который применяется к элементам web-страницы для управления их видом и положением.
|
||||
|
||||
Основной целью разработки CSS являлось разделение описания логической структуры web-страницы, которое производится с помощью HTML или других языков разметки от описания внешнего вида этой web-страницы, которое производится с помощью CSS.
|
||||
|
||||
[к оглавлению](#Основы-css)
|
||||
|
||||
##Как в CSS обозначаются комментарии?
|
||||
Чтобы пометить, что текст является комментарием, применяют конструкцию `/* ... */`
|
||||
|
||||
[к оглавлению](#Основы-css)
|
||||
|
||||
##Что такое _«селектор»_?
|
||||
__Селектор__ – это правило, на основании которого осуществляется выбор элементов в HTML документе для того, чтобы применить к ним определённые стили.
|
||||
|
||||
```css
|
||||
p {
|
||||
text-align: center;
|
||||
font-size: 20px;
|
||||
}
|
||||
/* p – это селектор, text-align и font-size – это свойства, а center и 20px – значения. */
|
||||
```
|
||||
|
||||
[к оглавлению](#Основы-css)
|
||||
|
||||
##Перечислите основные виды селекторов.
|
||||
|
||||
+ __селектор `*`__ - выбор всех элементов;
|
||||
+ __селектор элемента__ - выбор всех элементов в HTML документе, имеющих указанный тег (например: `div`);
|
||||
+ __селектор класса__ - выбор всех элементов в HTML документе, имеющих указанный класс (например: `.center`);
|
||||
+ __селектор идентификатора__ - выбор элемента в HTML документе, имеющего указанный идентификатор (например: `#footer`);
|
||||
+ __селекторы псевдоклассов__ - выбор всех элементов в HTML документе, имеющих указанный псевдокласс (например: `p:first-of-type`);
|
||||
+ __селекторы атрибутов__ - выбор элементов в зависимости от указанного атрибута элемента или его значения (например: `[href*="youtube"]`).
|
||||
|
||||
[к оглавлению](#Основы-css)
|
||||
|
||||
##Что такое псевдокласс?
|
||||
Псевдокласс определяет динамическое состояние элементов, которое изменяется из-за действий пользователя, или же соответствует текущему положению в дереве документа. В отличие от настоящего класса, в явном виде псеводкласс в HTML не указывается, а в CSS указывается через `:` непосредственно после селектора.
|
||||
|
||||
Наиболее известные псевдоклассы:
|
||||
|
||||
+ `:link` применяется к непосещенным ссылкам;
|
||||
+ `:visited` применяется к посещенным ссылкам;
|
||||
+ `:hover` применяется, когда курсор мыши находится в пределах элемента, но не активирует его;
|
||||
+ `:active` применяется при активации элемента;
|
||||
+ `:focus` применяется к элементу при получении им фокуса;
|
||||
+ `:first-child` применяется к первому дочернему элементу селектора, который расположен в дереве элементов документа.
|
||||
|
||||
```css
|
||||
a.snowman:link {
|
||||
color: blue;
|
||||
}
|
||||
a.snowman:visited {
|
||||
color: purple;
|
||||
}
|
||||
a.snowman:active {
|
||||
color: red;
|
||||
}
|
||||
a.snowman:hover {
|
||||
text-decoration: none;
|
||||
color: blue;
|
||||
background-color: yellow;
|
||||
}
|
||||
```
|
||||
|
||||
[к оглавлению](#Основы-css)
|
||||
|
||||
##Какие существуют селекторы аттрибутов?
|
||||
+ __`[атрибут]`__ - все элементы, имеющие указанный `атрибут`;
|
||||
+ __`[атрибут=значение]`__ - все элементы, имеющие `атрибут`, значение которого равно `"значение"`;
|
||||
+ __`[атрибут^=занчение]`__ - все элементы, имеющие `атрибут`, значение которого начинается с `значение`;
|
||||
+ __`[атрибут|=значение]`__ - все элементы, имеющие `атрибут`, значение которого равно `значение` или начинается с `значение` следующим образом `значение-*` (`значение` с обязательным дефисом, после которого идёт остальное содержимое значения);
|
||||
+ __`[атрибут$=значение]`__ - все элементы, имеющие `атрибут`, значение которого заканчивается на `значение`;
|
||||
+ __`[атрибут*=значение]`__ - все элементы, имеющие `атрибут`, значение которого содержит подстроку `значение`;
|
||||
+ __`[атрибут~=значение]`__ - все элементы, имеющие `атрибут`, значение которого содержит `значение` как одно из значений через пробел.
|
||||
|
||||
[к оглавлению](#Основы-css)
|
||||
|
||||
##В чем разница между `#my` и `.my`?
|
||||
`#my` — селектор идентификатора, а `.my` — селектор класса.
|
||||
|
||||
[к оглавлению](#Основы-css)
|
||||
|
||||
##В чем разница между `margin` и `padding`?
|
||||
`margin` — внешний отступ, а `padding` — внутренний отступ.
|
||||
|
||||
[к оглавлению](#Основы-css)
|
||||
|
||||
##В чем заключается разница между значениями `0` и `auto` в свойстве `margin`?
|
||||
В вертикальных полях — `auto` всегда означает `0`. В горизонтальных полях — `auto` означает `0` только тогда, когда свойство `width` также `auto`.
|
||||
|
||||
[к оглавлению](#Основы-css)
|
||||
|
||||
##Какое свойство задает цвет фона?
|
||||
Цвет фона задает свойство `background-color`.
|
||||
|
||||
[к оглавлению](#Основы-css)
|
||||
|
||||
##Как убрать подчеркивание для всех ссылок на странице?
|
||||
```css
|
||||
a {
|
||||
text-decoration: none;
|
||||
}
|
||||
```
|
||||
|
||||
[к оглавлению](#Основы-css)
|
||||
|
||||
##Для чего используется свойство `clear`?
|
||||
`clear` устанавливает, с какой стороны элемента запрещено его обтекание другими элементами.
|
||||
|
||||
[к оглавлению](#Основы-css)
|
||||
|
||||
##Как сделать жирным текст во всех элементах `<p>`?
|
||||
```css
|
||||
p {
|
||||
font-weight: bold;
|
||||
}
|
||||
```
|
||||
|
||||
[к оглавлению](#Основы-css)
|
||||
|
||||
##Как задать красный цвет для всех элементов, имеющих класс `red`?
|
||||
```css
|
||||
.red {
|
||||
color: red;
|
||||
}
|
||||
```
|
||||
|
||||
[к оглавлению](#Основы-css)
|
||||
|
||||
#Источники
|
||||
+ [myway-blog.ru](http://myway-blog.ru/interview-frontend-web-programmer/)
|
||||
+ [htmlbook.ru](http://stepbystep.htmlbook.ru/?id=43)
|
||||
+ [itchief.ru](https://itchief.ru/lessons/html-and-css/css-selectors)
|
||||
|
||||
|
|
@ -0,0 +1,273 @@
|
|||
[Вопросы для собеседования на Java Junior](README.md)
|
||||
|
||||
#Базы данных
|
||||
+ [Что такое _«база данных»_?](#Что-такое-база-данных)
|
||||
+ [Что такое _«система управления базами данных»_?](#Что-такое-система-управления-базами-данных)
|
||||
+ [Что такое _«реляционная модель данных»_?](#Что-такое-реляционная-модель-данных)
|
||||
+ [Дайте определение терминам _«простой»_, _«составной» (composite)_, _«потенциальный» (candidate)_ и _«альтернативный» (alternate)_ ключ.](#Дайте-определение-терминам-простой-составной-composite-потенциальный-candidate-и-альтернативный-alternate-ключ)
|
||||
+ [Что такое _«первичный ключ» (primary key)_? Каковы критерии его выбора?](#Что-такое-первичный-ключ-primary-key-Каковы-критерии-его-выбора)
|
||||
+ [Что такое _«внешний ключ» (foreign key)_?](#Что-такое-внешний-ключ-foreign-key)
|
||||
+ [Что такое _«нормализация»_?](#Что-такое-нормализация)
|
||||
+ [Какие существуют нормальные формы?](#Какие-существуют-нормальные-формы)
|
||||
+ [Что такое _«денормализация»_? Для чего она применяется?](#Что-такое-денормализация-Для-чего-она-применяется)
|
||||
+ [Какие существуют типы связей в базе данных? Приведите примеры.](#Какие-существуют-типы-связей-в-базе-данных-Приведите-примеры)
|
||||
+ [Что такое _«индексы»_? Для чего их используют? В чём заключаются их преимущества и недостатки?](#Что-такое-индексы-Для-чего-их-используют-В-чём-заключаются-их-преимущества-и-недостатки)
|
||||
+ [Какие типы индексов существуют?](#Какие-типы-индексов-существуют)
|
||||
+ [В чем отличие между кластерными и некластерными индексами?](#В-чем-отличие-между-кластерными-и-некластерными-индексами)
|
||||
+ [Имеет ли смысл индексировать данные, имеющие небольшое количество возможных значений?](#Имеет-ли-смысл-индексировать-данные-имеющие-небольшое-количество-возможных-значений)
|
||||
+ [Когда полное сканирование набора данных выгоднее доступа по индексу?](#Когда-полное-сканирование-набора-данных-выгоднее-доступа-по-индексу)
|
||||
+ [Что такое _«транзакция»_?](#Что-такое-транзакция)
|
||||
+ [Назовите основные свойства транзакции.](#Назовите-основные-свойства-транзакции)
|
||||
+ [Какие существуют уровни изолированности транзакций?](#Какие-существуют-уровни-изолированности-транзакций)
|
||||
+ [Какие проблемы могут возникать при параллельном доступе с использованием транзакций?](#Какие-проблемы-могут-возникать-при-параллельном-доступе-с-использованием-транзакций)
|
||||
|
||||
##Что такое _«база данных»_?
|
||||
__База данных__ — организованный и адаптированный для обработки вычислительной системой набор информации.
|
||||
|
||||
[к оглавлению](#Базы-данных)
|
||||
|
||||
##Что такое _«система управления базами данных»_?
|
||||
__Система управления базами данных (СУБД)__ - набор средств общего или специального назначения, обеспечивающий создание, доступ к материалам и управление базой данных.
|
||||
|
||||
Основные функции СУБД:
|
||||
|
||||
+ управление данными
|
||||
+ журнализация изменений данных
|
||||
+ резервное копирование и восстановление данных;
|
||||
+ поддержка языка определения данных и манипулирования ими.
|
||||
|
||||
[к оглавлению](#Базы-данных)
|
||||
|
||||
##Что такое _«реляционная модель данных»_?
|
||||
__Реляционная модель данных__ — это логическая модель данных и прикладная теория построения реляционных баз данных.
|
||||
|
||||
Реляционная модель данных включает в себя следующие компоненты:
|
||||
|
||||
+ _Структурный аспект_ — данные представляют собой набор отношений.
|
||||
+ _Аспект целостности_ — отношения отвечают определенным условиям целостности: уровня домена (типа данных), уровня отношения и уровня базы данных.
|
||||
+ _Аспект обработки (манипулирования)_ — поддержка операторов манипулирования отношениями (реляционная алгебра, реляционное исчисление).
|
||||
+ _Нормальная форма_ - свойство отношения в реляционной модели данных, характеризующее его с точки зрения избыточности и определённое как совокупность требований, которым должно удовлетворять отношение.
|
||||
|
||||
[к оглавлению](#Базы-данных)
|
||||
|
||||
##Дайте определение терминам _«простой»_, _«составной» (composite)_, _«потенциальный» (candidate)_ и _«альтернативный» (alternate)_ ключ.
|
||||
__Простой ключ__ состоит из одного атрибута (поля). __Составной__ - из двух и более.
|
||||
|
||||
__Потенциальный ключ__ - простой или составной ключ, который уникально идентифицирует каждую запись набора данных. При этом потенциальный ключ должен обладать критерием неизбыточности: при удалении любого из полей набор полей перестает уникально идентифицировать запись.
|
||||
|
||||
Из множества всех потенциальных ключей набора данных выбирают первичный ключ, все остальные ключи называют __альтернативными__.
|
||||
|
||||
[к оглавлению](#Базы-данных)
|
||||
|
||||
##Что такое _«первичный ключ» (primary key)_? Каковы критерии его выбора?
|
||||
__Первичный ключ (primary key)__ в реляционной модели данных один из _потенциальных ключей_ отношения, выбранный в качестве основного ключа (ключа по умолчанию).
|
||||
|
||||
Если в отношении имеется единственный потенциальный ключ, он является и первичным ключом. Если потенциальных ключей несколько, один из них выбирается в качестве первичного, а другие называют _«альтернативными»_.
|
||||
|
||||
В качестве первичного обычно выбирается тот из потенциальных ключей, который наиболее удобен. Поэтому в качестве первичного ключа, как правило, выбирают тот, который имеет наименьший размер (физического хранения) и/или включает наименьшее количество атрибутов. Другой критерий выбора первичного ключа — сохранение его уникальности со временем. Поэтому в качестве первичного ключа стараются выбирать такой потенциальный ключ, который с наибольшей вероятностью никогда не утратит уникальность.
|
||||
|
||||
[к оглавлению](#Базы-данных)
|
||||
|
||||
##Что такое _«внешний ключ» (foreign key)_?
|
||||
__Внешний ключ (foreign key)__ — подмножество атрибутов некоторого отношения A, значения которых должны совпадать со значениями некоторого потенциального ключа некоторого отношения B.
|
||||
|
||||
[к оглавлению](#Базы-данных)
|
||||
|
||||
##Что такое _«нормализация»_?
|
||||
_Нормализация_ - это процесс преобразования отношений базы данных к виду, отвечающему нормальным формам (пошаговый, обратимый процесс замены исходной схемы другой схемой, в которой наборы данных имеют более простую и логичную структуру).
|
||||
|
||||
Нормализация предназначена для приведения структуры базы данных к виду, обеспечивающему минимальную логическую избыточность, и не имеет целью уменьшение или увеличение производительности работы или же уменьшение или увеличение физического объёма базы данных. Конечной целью нормализации является уменьшение потенциальной противоречивости хранимой в базе данных информации.
|
||||
|
||||
[к оглавлению](#Базы-данных)
|
||||
|
||||
##Какие существуют нормальные формы?
|
||||
__Первая нормальная форма (1NF)__ - Отношение находится в 1NF, если значения всех его атрибутов атомарны (неделимы).
|
||||
|
||||
__Вторая нормальная форма (2NF)__ - Отношение находится в 2NF, если оно находится в 1NF, и при этом все неключевые атрибуты зависят только от ключа целиком, а не от какой-то его части.
|
||||
|
||||
__Третья нормальная форма (3NF)__ - Отношение находится в 3NF, если оно находится в 2NF и все неключевые атрибуты не зависят друг от друга.
|
||||
|
||||
__Четвёртая нормальная форма (4NF)__ - Отношение находится в 4NF , если оно находится в 3NF и если в нем не содержатся независимые группы атрибутов, между которыми существует отношение «многие-ко-многим».
|
||||
|
||||
__Пятая нормальная форма (5NF)__ - Отношение находится в 5NF, когда каждая нетривиальная зависимость соединения в ней определяется потенциальным ключом (ключами) этого отношения.
|
||||
|
||||
__Шестая нормальная форма (6NF)__ - Отношение находится в 6NF, когда она удовлетворяет всем нетривиальным зависимостям соединения, т.е. когда она неприводима, то есть не может быть подвергнута дальнейшей декомпозиции без потерь. Каждая переменная отношения, которая находится в 6NF, также находится и в 5NF. Введена как обобщение пятой нормальной формы для хронологической базы данных.
|
||||
|
||||
__Нормальная форма Бойса-Кодда, усиленная 3 нормальная форма (BCNF)__ - Отношение находится в BCNF, когда каждая её нетривиальная и неприводимая слева функциональная зависимость имеет в качестве своего детерминанта некоторый потенциальный ключ.
|
||||
|
||||
__Доменно-ключевая нормальная форма (DKNF)__ - Отношение находится в DKNF, когда каждое наложенное на неё ограничение является логическим следствием ограничений доменов и ограничений ключей, наложенных на данное отношение.
|
||||
|
||||
[к оглавлению](#Базы-данных)
|
||||
|
||||
##Что такое _«денормализация»_? Для чего она применяется?
|
||||
__Денормализация базы данных__ — это процесс осознанного приведения базы данных к виду, в котором она не будет соответствовать правилам нормализации. Обычно это необходимо для повышения производительности и скорости извлечения данных, за счет увеличения избыточности данных.
|
||||
|
||||
[к оглавлению](#Базы-данных)
|
||||
|
||||
##Какие существуют типы связей в базе данных? Приведите примеры.
|
||||
+ __Один к одному__ - любому значению атрибута А соответствует только одно значение атрибута В, и наоборот.
|
||||
|
||||
>Каждый университет гарантированно имеет 1-го ректора: _1 университет → 1 ректор_.
|
||||
|
||||
+ __Один ко многим__ - любому значению атрибута А соответствует 0, 1 или несколько значений атрибута В.
|
||||
|
||||
>В каждом университете есть несколько факультетов: _1 университет → много факультетов_.
|
||||
|
||||
+ __Многие ко многим__ - любому значению атрибута А соответствует 0, 1 или несколько значений атрибута В, и любому значению атрибута В соответствует 0, 1 или несколько значение атрибута А.
|
||||
|
||||
>1 профессор может преподавать на нескольких факультетах, в то же время на 1-ом факультете может преподавать несколько профессоров: _Несколько профессоров ↔ Несколько факультетов_.
|
||||
|
||||
[к оглавлению](#Базы-данных)
|
||||
|
||||
##Что такое _«индексы»_? Для чего их используют? В чём заключаются их преимущества и недостатки?
|
||||
__Индекс (index)__ — объект базы данных, создаваемый с целью повышения производительности выборки данных.
|
||||
|
||||
Наборы данных могут иметь большое количество записей, которые хранятся в произвольном порядке, и их поиск по заданному критерию путём последовательного просмотра набора данных запись за записью может занимать много времени. Индекс формируется из значений одного или нескольких полей и указателей на соответствующие записи набора данных, - таким образом, достигается значительный прирост скорости выборки из этих данных.
|
||||
|
||||
Преимущества
|
||||
|
||||
+ ускорение поиска и сортировки по определенному полю или набору полей.
|
||||
+ обеспечение уникальности данных.
|
||||
|
||||
Недостатки
|
||||
|
||||
+ требование дополнительного места на диске и в оперативной памяти и чем больше/длиннее ключ, тем больше размер индекса.
|
||||
+ замедление операций вставки, обновления и удаления записей, поскольку при этом приходится обновлять сами индексы.
|
||||
|
||||
Индексы предпочтительней для:
|
||||
|
||||
+ Поля-счетчика, чтобы в том числе избежать и повторения значений в этом поле;
|
||||
+ Поля, по которому проводится сортировка данных;
|
||||
+ Полей, по которым часто проводится соединение наборов данных. Поскольку в этом случае данные располагаются в порядке возрастания индекса и соединение происходит значительно быстрее;
|
||||
+ Поля, которое объявлено первичным ключом (primary key);
|
||||
+ Поля, в котором данные выбираются из некоторого диапазона. В этом случае как только будет найдена первая запись с нужным значением, все последующие значения будут расположены рядом.
|
||||
|
||||
Использование индексов нецелесообразно для:
|
||||
|
||||
+ Полей, которые редко используются в запросах;
|
||||
+ Полей, которые содержат всего два или три значения, например: _мужской_, _женский пол_ или значения _«да»_, _«нет»_.
|
||||
|
||||
[к оглавлению](#Базы-данных)
|
||||
|
||||
##Какие типы индексов существуют?
|
||||
|
||||
__По порядку сортировки__
|
||||
+ _упорядоченные_ — индексы, в которых элементы упорядочены;
|
||||
+ _возрастающие_;
|
||||
+ _убывающие_;
|
||||
+ _неупорядоченные_ — индексы, в которых элементы неупорядочены.
|
||||
|
||||
__По источнику данных__
|
||||
+ _индексы по представлению (view)_;
|
||||
+ _индексы по выражениям_.
|
||||
|
||||
__По воздействию на источник данных__
|
||||
+ _кластерный индекс_ - при определении в наборе данных физическое расположение данных перестраивается в соответствии со структурой индекса. Логическая структура набора данных в этом случае представляет собой скорее словарь, чем индекс. Данные в словаре физически упорядочены, например по алфавиту. Кластерные индексы могут дать существенное увеличение производительности поиска данных даже по сравнению с обычными индексами. Увеличение производительности особенно заметно при работе с последовательными данными.
|
||||
+ _некластерный индекс_ — наиболее типичные представители семейства индексов. В отличие от кластерных, они не перестраивают физическую структуру набора данных, а лишь организуют ссылки на соответствующие записи. Для идентификации нужной записи в наборе данных некластерный индекс организует специальные указатели, включающие в себя: информацию об идентификационном номере файла, в котором хранится запись; идентификационный номер страницы соответствующих данных; номер искомой записи на соответствующей странице; содержимое столбца.
|
||||
|
||||
__По структуре__
|
||||
+ _B*-деревья_;
|
||||
+ _B+-деревья_;
|
||||
+ _B-деревья_;
|
||||
+ _Хэши_.
|
||||
|
||||
__По количественному составу__
|
||||
+ _простой индекс (индекс с одним ключом)_ — строится по одному полю;
|
||||
+ _составной (многоключевой, композитный) индекс_ — строится по нескольким полям при этом важен порядок их следования;
|
||||
+ _индекс с включенными столбцами_ — некластеризованный индекс, дополнительно содержащий кроме ключевых столбцов еще и неключевые;
|
||||
+ _главный индекс (индекс по первичному ключу)_ — это тот индексный ключ, под управлением которого в данный момент находится набор данных. Набор данных не может быть отсортирован по нескольким индексным ключам одновременно. Хотя, если один и тот же набор данных открыт одновременно в нескольких рабочих областях, то у каждой копии набора данных может быть назначен свой главный индекс.
|
||||
|
||||
__По характеристике содержимого__
|
||||
+ _уникальный индекс_ состоит из множества уникальных значений поля;
|
||||
+ _плотный индекс_ (NoSQL) — индекс, при котором, каждом документе в индексируемой коллекции соответствует запись в индексе, даже если в документе нет индексируемого поля.
|
||||
+ _разреженный индекс_ (NoSQL) — тот, в котором представлены только те документы, для которых индексируемый ключ имеет какое-то определённое значение (существует).
|
||||
+ _пространственный индекс_ — оптимизирован для описания географического местоположения. Представляет из себя многоключевой индекс состоящий из широты и долготы.
|
||||
+ _составной пространственный индекс_ — индекс, включающий в себя кроме широты и долготы ещё какие-либо мета-данные (например теги). Но географические координаты должны стоять на первом месте.
|
||||
+ _полнотекстовый (инвертированный) индекс_ — словарь, в котором перечислены все слова и указано, в каких местах они встречаются. При наличии такого индекса достаточно осуществить поиск нужных слов в нём и тогда сразу же будет получен список документов, в которых они встречаются.
|
||||
+ _хэш-индекс_ предполагает хранение не самих значений, а их хэшей, благодаря чему уменьшается размер (а, соответственно, и увеличивается скорость их обработки) индексов из больших полей. Таким образом, при запросах с использованием хэш-индексов, сравниваться будут не искомое со значения поля, а хэш от искомого значения с хэшами полей.
|
||||
Из-за нелинейнойсти хэш-функций данный индекс нельзя сортировать по значению, что приводит к невозможности использования в сравнениях больше/меньше и «is null». Кроме того, так как хэши не уникальны, то для совпадающих хэшей применяются методы разрешения коллизий.
|
||||
+ _битовый индекс (bitmap index)_ — метод битовых индексов заключается в создании отдельных битовых карт (последовательностей 0 и 1) для каждого возможного значения столбца, где каждому биту соответствует запись с индексируемым значением, а его значение равное 1 означает, что запись, соответствующая позиции бита содержит индексируемое значение для данного столбца или свойства.
|
||||
+ _обратный индекс (reverse index)_ — B-tree индекс, но с реверсированным ключом, используемый в основном для монотонно возрастающих значений (например, автоинкрементный идентификатор) в OLTP системах с целью снятия конкуренции за последний листовой блок индекса, т.к. благодаря переворачиванию значения две соседние записи индекса попадают в разные блоки индекса. Он не может использоваться для диапазонного поиска.
|
||||
+ _функциональный индекс, индекс по вычисляемому полю (function-based index)_ — индекс, ключи которого хранят результат пользовательских функций. Функциональные индексы часто строятся для полей, значения которых проходят предварительную обработку перед сравнением в команде SQL. Например, при сравнении строковых данных без учета регистра символов часто используется функция UPPER. Кроме того, функциональный индекс может помочь реализовать любой другой отсутствующий тип индексов данной СУБД.
|
||||
+ _первичный индекс_ — уникальный индекс по полю первичного ключа.
|
||||
+ _вторичный индекс_ — индекс по другим полям (кроме поля первичного ключа).
|
||||
+ _XML-индекс_ — вырезанное материализованное представление больших двоичных XML-объектов (BLOB) в столбце с типом данных xml.
|
||||
|
||||
__По механизму обновления__
|
||||
+ _полностью перестраиваемый_ — при добавлении элемента заново перестраивается весь индекс.
|
||||
+ _пополняемый (балансируемый)_ — при добавлении элементов индекс перестраивается частично (например одна из ветви) и периодически балансируется.
|
||||
|
||||
__По покрытию индексируемого содержимого__
|
||||
+ _полностью покрывающий (полный) индекс_ — покрывает всё содержимое индексируемого объекта.
|
||||
+ _частичный индекс (partial index)_ — это индекс, построенный на части набора данных, удовлетворяющей определенному условию самого индекса. Данный индекс создан для уменьшения размера индекса.
|
||||
+ _инкрементный (delta) индекс_ — индексируется малая часть данных(дельта), как правило, по истечении определённого времени. Используется при интенсивной записи. Например, полный индекс перестраивается раз в сутки, а дельта-индекс строится каждый час. По сути это частичный индекс по временной метке.
|
||||
+ _индекс реального времени (real-time index)_ — особый вид инкрементного индекса, характеризующийся высокой скоростью построения. Предназначен для часто меняющихся данных.
|
||||
|
||||
__Индексы в кластерных системах__
|
||||
+ _глобальный индекс_ — индекс по всему содержимому всех сегментов БД (shard).
|
||||
+ _сегментный индекс_ — глобальный индекс по полю-сегментируемому ключу (shard key). Используется для быстрого определения сегмента, на котором хранятся данные в процессе маршрутизации запроса в кластере БД.
|
||||
+ _локальный индекс_ — индекс по содержимому только одного сегмента БД.
|
||||
|
||||
[к оглавлению](#Базы-данных)
|
||||
|
||||
##В чем отличие между кластерными и некластерными индексами?
|
||||
Некластерные индексы - данные физически расположены в произвольном порядке, но логически упорядочены согласно индексу. Такой тип индексов подходит для часто изменяемого набора данных.
|
||||
|
||||
При кластерном индексировании данные физически упорядочены, что серьезно повышает скорость выборок данных (но только в случае последовательного доступа к данным). Для одного набора данных может быть создан только один кластерный индекс.
|
||||
|
||||
[к оглавлению](#Базы-данных)
|
||||
|
||||
##Имеет ли смысл индексировать данные, имеющие небольшое количество возможных значений?
|
||||
Примерное правило, которым можно руководствоваться при создании индекса - если объем информации (в байтах) НЕ удовлетворяющей условию выборки меньше, чем размер индекса (в байтах) по данному условию выборки, то в общем случае оптимизация приведет к замедлению выборки.
|
||||
|
||||
[к оглавлению](#Базы-данных)
|
||||
|
||||
##Когда полное сканирование набора данных выгоднее доступа по индексу?
|
||||
Полное сканирование производится многоблочным чтением. Сканирование по индексу - одноблочным. Также, при доступе по индексу сначала идет сканирование самого индекса, а затем чтение блоков из набора данных. Число блоков, которые надо при этом прочитать из набора зависит от фактора кластеризации. Если суммарная стоимость всех необходимых одноблочных чтений больше стоимости полного сканирования многоблочным чтением, то полное сканирование выгоднее и оно выбирается оптимизатором.
|
||||
|
||||
Таким образом, полное сканирование выбирается при слабой селективности предикатов зароса и/или слабой кластеризации данных, либо в случае очень маленьких наборов данных.
|
||||
|
||||
[к оглавлению](#Базы-данных)
|
||||
|
||||
##Что такое _«транзакция»_?
|
||||
__Транзакция__ - это воздействие на базу данных, переводящее её из одного целостного состояния в другое и выражаемое в изменении данных, хранящихся в базе данных.
|
||||
|
||||
[к оглавлению](#Базы-данных)
|
||||
|
||||
##Назовите основные свойства транзакции.
|
||||
__Атомарность (atomicity)__ гарантирует, что никакая транзакция не будет зафиксирована в системе частично. Будут либо выполнены все её подоперации, либо не выполнено ни одной.
|
||||
|
||||
__Согласованность (consistency)__. Транзакция, достигающая своего нормального завершения и, тем самым, фиксирующая свои результаты, сохраняет согласованность базы данных.
|
||||
|
||||
__Изолированность (isolation)__. Во время выполнения транзакции параллельные транзакции не должны оказывать влияние на её результат.
|
||||
|
||||
__Долговечность (durability)__. Независимо от проблем на нижних уровнях (к примеру, обесточивание системы или сбои в оборудовании) изменения, сделанные успешно завершённой транзакцией, должны остаться сохранёнными после возвращения системы в работу.
|
||||
|
||||
[к оглавлению](#Базы-данных)
|
||||
|
||||
##Какие существуют уровни изолированности транзакций?
|
||||
В порядке увеличения изолированности транзакций и, соответственно, надёжности работы с данными:
|
||||
|
||||
+ __Чтение неподтверждённых данных (грязное чтение) (read uncommitted, dirty read)__ — чтение незафиксированных изменений как своей транзакции, так и параллельных транзакций. Нет гарантии, что данные, изменённые другими транзакциями, не будут в любой момент изменены в результате их отката, поэтому такое чтение является потенциальным источником ошибок. Невозможны потерянные изменения, возможны неповторяемое чтение и фантомы.
|
||||
+ __Чтение подтверждённых данных (read committed)__ — чтение всех изменений своей транзакции и зафиксированных изменений параллельных транзакций. Потерянные изменения и грязное чтение не допускается, возможны неповторяемое чтение и фантомы.
|
||||
+ __Повторяемость чтения (repeatable read, snapshot)__ — чтение всех изменений своей транзакции, любые изменения, внесённые параллельными транзакциями после начала своей, недоступны. Потерянные изменения, грязное и неповторяемое чтение невозможны, возможны фантомы.
|
||||
+ __Упорядочиваемость (serializable)__ — результат параллельного выполнения сериализуемой транзакции с другими транзакциями должен быть логически эквивалентен результату их какого-либо последовательного выполнения. Проблемы синхронизации не возникают.
|
||||
|
||||
[к оглавлению](#Базы-данных)
|
||||
|
||||
##Какие проблемы могут возникать при параллельном доступе с использованием транзакций?
|
||||
При параллельном выполнении транзакций возможны следующие проблемы:
|
||||
|
||||
+ __Потерянное обновление (lost update)__ — при одновременном изменении одного блока данных разными транзакциями одно из изменений теряется;
|
||||
+ __«Грязное» чтение (dirty read)__ — чтение данных, добавленных или изменённых транзакцией, которая впоследствии не подтвердится (откатится);
|
||||
+ __Неповторяющееся чтение (non-repeatable read)__ — при повторном чтении в рамках одной транзакции ранее прочитанные данные оказываются изменёнными;
|
||||
+ __Фантомное чтение (phantom reads)__ — одна транзакция в ходе своего выполнения несколько раз выбирает множество записей по одним и тем же критериям. Другая транзакция в интервалах между этими выборками добавляет или удаляет записи или изменяет столбцы некоторых записей, используемых в критериях выборки первой транзакции, и успешно заканчивается. В результате получится, что одни и те же выборки в первой транзакции дают разные множества записей.
|
||||
|
||||
[к оглавлению](#Базы-данных)
|
||||
|
||||
|
||||
|
||||
#Источники
|
||||
+ [Википедия](https://ru.wikipedia.org/wiki/)
|
||||
+ [tokarchuk.ru](http://tokarchuk.ru/2012/08/indexes-classification/)
|
||||
+ [Quizful](http://www.quizful.net/interview/sql/)
|
||||
|
|
@ -0,0 +1,21 @@
|
|||
The MIT License (MIT)
|
||||
|
||||
Copyright (c) 2016 Pavel Kalinin
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
in the Software without restriction, including without limitation the rights
|
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in all
|
||||
copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
SOFTWARE.
|
||||
|
|
@ -0,0 +1,6 @@
|
|||
# Learning Java
|
||||
1. [Homeworks](https://github.com/enhorse/learningJava/tree/master/src/main/java/xyz/enhorse/javarush) for the course from [Java Rush](http://javarush.ru/)
|
||||
2. [Homeworks](https://github.com/enhorse/learningJava/tree/master/src/main/java/xyz/enhorse/m101j) for the course [M101J: MongoDB for Java Developers](https://university.mongodb.com/courses/M101J/about)
|
||||
3. [Homeworks](https://github.com/enhorse/learningJava/tree/master/src/main/java/xyz/enhorse/stepic/algo) for the course [Алгоритмы: теория и практика. Методы](https://stepic.org/course/217)
|
||||
4. [Homeworks](https://github.com/enhorse/learningJava/tree/master/src/main/java/xyz/enhorse/stepic/djwebservice) for the course [Разработка веб сервиса на Java (часть 1)](https://stepic.org/course/146)
|
||||
5. [Homeworks](https://github.com/enhorse/learningJava/tree/master/src/main/java/xyz/enhorse/stepic/hadoop) for the course [Hadoop. Система для обработки больших объемов данных](https://stepic.org/course/150)
|
||||
|
|
@ -0,0 +1,153 @@
|
|||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
|
||||
xmlns="http://maven.apache.org/POM/4.0.0"
|
||||
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
|
||||
<modelVersion>4.0.0</modelVersion>
|
||||
|
||||
<groupId>xyz.enhorse</groupId>
|
||||
<artifactId>example</artifactId>
|
||||
<version>1.0-SNAPSHOT</version>
|
||||
|
||||
<packaging>jar</packaging>
|
||||
|
||||
<properties>
|
||||
<start-class>xyz.enhorse.example.Application</start-class>
|
||||
|
||||
<java.version>1.8</java.version>
|
||||
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
|
||||
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
|
||||
|
||||
<maven.compiler.version>3.6.0</maven.compiler.version>
|
||||
<maven.assembly.version>3.0.0</maven.assembly.version>
|
||||
<maven.checkstyle.version>2.17</maven.checkstyle.version>
|
||||
<maven.jxr.version>2.5</maven.jxr.version>
|
||||
<exec.version>1.5.0</exec.version>
|
||||
|
||||
<maven.compiler.useIncrementalCompilation>false</maven.compiler.useIncrementalCompilation>
|
||||
<checkstyle.config>src/main/resources/google_checkstyle.xml</checkstyle.config>
|
||||
|
||||
<junit.version>4.12</junit.version>
|
||||
<mockito.version>2.5.0</mockito.version>
|
||||
<log4j.version>1.7.22</log4j.version>
|
||||
</properties>
|
||||
|
||||
<name>
|
||||
Examples
|
||||
</name>
|
||||
<description>
|
||||
Examples for Java Developer interview preparation materials
|
||||
</description>
|
||||
<url>https://github.com/enhorse/</url>
|
||||
|
||||
<developers>
|
||||
<developer>
|
||||
<name>Pavel Kalinin</name>
|
||||
<email>go2amd@gmail.com</email>
|
||||
<organization>fairy stable</organization>
|
||||
<organizationUrl>https://enhorse.xyz</organizationUrl>
|
||||
<roles>
|
||||
<role>build maintainer</role>
|
||||
<role>release manager</role>
|
||||
</roles>
|
||||
</developer>
|
||||
</developers>
|
||||
|
||||
<licenses>
|
||||
<license>
|
||||
<name>MIT License</name>
|
||||
<url>LICENSE</url>
|
||||
<distribution>repo</distribution>
|
||||
</license>
|
||||
</licenses>
|
||||
|
||||
<dependencies>
|
||||
<!-- Logging -->
|
||||
<dependency>
|
||||
<groupId>org.slf4j</groupId>
|
||||
<artifactId>slf4j-log4j12</artifactId>
|
||||
<version>${log4j.version}</version>
|
||||
</dependency>
|
||||
<!-- Testing -->
|
||||
<dependency>
|
||||
<groupId>junit</groupId>
|
||||
<artifactId>junit</artifactId>
|
||||
<version>${junit.version}</version>
|
||||
<scope>test</scope>
|
||||
</dependency>
|
||||
<dependency>
|
||||
<groupId>org.mockito</groupId>
|
||||
<artifactId>mockito-core</artifactId>
|
||||
<version>${mockito.version}</version>
|
||||
<scope>test</scope>
|
||||
</dependency>
|
||||
</dependencies>
|
||||
|
||||
<build>
|
||||
<plugins>
|
||||
<plugin>
|
||||
<groupId>org.apache.maven.plugins</groupId>
|
||||
<artifactId>maven-compiler-plugin</artifactId>
|
||||
<version>${maven.compiler.version}</version>
|
||||
<configuration>
|
||||
<source>${java.version}</source>
|
||||
<target>${java.version}</target>
|
||||
</configuration>
|
||||
</plugin>
|
||||
<plugin>
|
||||
<groupId>org.apache.maven.plugins</groupId>
|
||||
<artifactId>maven-assembly-plugin</artifactId>
|
||||
<version>${maven.assembly.version}</version>
|
||||
<configuration>
|
||||
<descriptorRefs>
|
||||
<descriptorRef>jar-with-dependencies</descriptorRef>
|
||||
</descriptorRefs>
|
||||
<archive>
|
||||
<manifest>
|
||||
<mainClass>${start-class}</mainClass>
|
||||
</manifest>
|
||||
</archive>
|
||||
</configuration>
|
||||
<executions>
|
||||
<execution>
|
||||
<phase>package</phase>
|
||||
<goals>
|
||||
<goal>single</goal>
|
||||
</goals>
|
||||
</execution>
|
||||
</executions>
|
||||
</plugin>
|
||||
<plugin>
|
||||
<groupId>org.apache.maven.plugins</groupId>
|
||||
<artifactId>maven-checkstyle-plugin</artifactId>
|
||||
<version>${maven.checkstyle.version}</version>
|
||||
<configuration>
|
||||
<consoleOutput>true</consoleOutput>
|
||||
</configuration>
|
||||
<executions>
|
||||
<execution>
|
||||
<id>checkstyle</id>
|
||||
<phase>validate</phase>
|
||||
<goals>
|
||||
<goal>check</goal>
|
||||
</goals>
|
||||
<configuration>
|
||||
<configLocation>${checkstyle.config}</configLocation>
|
||||
<failOnViolation>true</failOnViolation>
|
||||
<consoleOutput>true</consoleOutput>
|
||||
</configuration>
|
||||
</execution>
|
||||
</executions>
|
||||
</plugin>
|
||||
</plugins>
|
||||
</build>
|
||||
|
||||
<reporting>
|
||||
<plugins>
|
||||
<plugin>
|
||||
<groupId>org.apache.maven.plugins</groupId>
|
||||
<artifactId>maven-jxr-plugin</artifactId>
|
||||
<version>${maven.jxr.version}</version>
|
||||
</plugin>
|
||||
</plugins>
|
||||
</reporting>
|
||||
</project>
|
||||
|
|
@ -0,0 +1,8 @@
|
|||
package xyz.enhorse.example;
|
||||
|
||||
public class Application {
|
||||
|
||||
public static void main(String[] args) {
|
||||
System.out.println("Examples for Java Developer interview preparation materials!");
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,56 @@
|
|||
package xyz.enhorse.example.concurrency;
|
||||
|
||||
import org.slf4j.Logger;
|
||||
import org.slf4j.LoggerFactory;
|
||||
|
||||
/**
|
||||
* @author <a href="mailto:go2amd@gmail.com">enhorse</a>
|
||||
* 17.01.2017
|
||||
*/
|
||||
public class VolatileBehaviour {
|
||||
|
||||
private static final Logger LOGGER = LoggerFactory.getLogger(VolatileBehaviour.class);
|
||||
|
||||
//private static long MY_INT = 0;
|
||||
private static volatile long MY_INT = 0;
|
||||
|
||||
|
||||
public static void main(String[] args) {
|
||||
new ChangeListener().start();
|
||||
new ChangeMaker().start();
|
||||
}
|
||||
|
||||
|
||||
static class ChangeListener extends Thread {
|
||||
|
||||
@Override
|
||||
public void run() {
|
||||
long local_value = MY_INT;
|
||||
while (local_value < 5) {
|
||||
if (local_value != MY_INT) {
|
||||
LOGGER.info("Got Change for MY_INT : " + MY_INT);
|
||||
local_value = MY_INT;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static class ChangeMaker extends Thread {
|
||||
|
||||
@Override
|
||||
public void run() {
|
||||
|
||||
long local_value = MY_INT;
|
||||
while (MY_INT < 5) {
|
||||
LOGGER.info("Incrementing MY_INT to " + (local_value + 1));
|
||||
MY_INT = ++local_value;
|
||||
try {
|
||||
Thread.sleep(500);
|
||||
} catch (InterruptedException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,79 @@
|
|||
package xyz.enhorse.example.concurrency;
|
||||
|
||||
/**
|
||||
* @author <a href="mailto:pavel13kalinin@gmail.com">Pavel Kalinin</a>
|
||||
* 21.10.2016
|
||||
*/
|
||||
public class WaitNotify {
|
||||
|
||||
private static final Object lock = new Object();
|
||||
private static volatile boolean isTick = true;
|
||||
|
||||
|
||||
public static void main(String[] args) {
|
||||
int concurrency = 333;
|
||||
|
||||
for (int i = 0; i < concurrency; i++) {
|
||||
new Tick(i).start();
|
||||
}
|
||||
|
||||
for (int i = 0; i < concurrency; i++) {
|
||||
new Tock(i).start();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
private static class Tick extends Thread {
|
||||
|
||||
private final int number;
|
||||
|
||||
|
||||
Tick(int number) {
|
||||
this.number = number;
|
||||
}
|
||||
|
||||
|
||||
@Override
|
||||
public void run() {
|
||||
synchronized (lock) { //use monitor of lock
|
||||
try {
|
||||
while (!isTick) {
|
||||
lock.wait(); //wait for our turn
|
||||
}
|
||||
System.out.printf("Tick[%03d]\n", number);
|
||||
isTick = false;
|
||||
lock.notifyAll(); //tell about that we made our job
|
||||
} catch (InterruptedException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private static class Tock extends Thread {
|
||||
|
||||
private final int number;
|
||||
|
||||
|
||||
Tock(int number) {
|
||||
this.number = number;
|
||||
}
|
||||
|
||||
|
||||
@Override
|
||||
public void run() {
|
||||
synchronized (lock) {
|
||||
try {
|
||||
while (isTick) {
|
||||
lock.wait();
|
||||
}
|
||||
System.out.printf(" Tock[%03d]\n", number);
|
||||
isTick = true;
|
||||
lock.notifyAll();
|
||||
} catch (InterruptedException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,69 @@
|
|||
package xyz.enhorse.example.oop;
|
||||
|
||||
/**
|
||||
* @author <a href="mailto:pavel13kalinin@gmail.com">Pavel Kalinin</a>
|
||||
* 21.10.2016
|
||||
*/
|
||||
public class PolymorphicTicTock {
|
||||
|
||||
public static void main(String[] args) {
|
||||
final int times = 10;
|
||||
|
||||
Commander commander = new Commander(TickTock.TICK);
|
||||
commander.run(times);
|
||||
}
|
||||
|
||||
|
||||
private enum TickTock {
|
||||
TICK("tick") {
|
||||
@Override
|
||||
TickTock opposite() {
|
||||
return TOCK;
|
||||
}
|
||||
},
|
||||
TOCK("tock") {
|
||||
@Override
|
||||
TickTock opposite() {
|
||||
return TICK;
|
||||
}
|
||||
};
|
||||
|
||||
private String content;
|
||||
|
||||
|
||||
TickTock(final String content) {
|
||||
this.content = content;
|
||||
}
|
||||
|
||||
|
||||
void say() {
|
||||
System.out.println(content);
|
||||
}
|
||||
|
||||
|
||||
abstract TickTock opposite();
|
||||
}
|
||||
|
||||
private static class Commander {
|
||||
|
||||
private TickTock current;
|
||||
|
||||
|
||||
Commander(final TickTock current) {
|
||||
this.current = current;
|
||||
}
|
||||
|
||||
|
||||
void once() {
|
||||
current.say();
|
||||
current = current.opposite();
|
||||
}
|
||||
|
||||
|
||||
void run(final int times) {
|
||||
for (int i = 0; i < (times * 2); i++) {
|
||||
once();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,196 @@
|
|||
<?xml version="1.0"?>
|
||||
<!DOCTYPE module PUBLIC
|
||||
"-//Puppy Crawl//DTD Check Configuration 1.3//EN"
|
||||
"http://www.puppycrawl.com/dtds/configuration_1_3.dtd">
|
||||
|
||||
<!--
|
||||
Checkstyle configuration that checks the Google coding conventions from Google Java Style
|
||||
that can be found at https://google.github.io/styleguide/javaguide.html.
|
||||
|
||||
Checkstyle is very configurable. Be sure to read the documentation at
|
||||
http://checkstyle.sf.net (or in your downloaded distribution).
|
||||
|
||||
To completely disable a check, just comment it out or delete it from the file.
|
||||
|
||||
Authors: Max Vetrenko, Ruslan Diachenko, Roman Ivanov.
|
||||
-->
|
||||
|
||||
<module name="Checker">
|
||||
<property name="charset" value="UTF-8"/>
|
||||
|
||||
<property name="severity" value="error"/>
|
||||
|
||||
<property name="fileExtensions" value="java, properties, xml"/>
|
||||
<!-- Checks for whitespace -->
|
||||
<!-- See http://checkstyle.sf.net/config_whitespace.html -->
|
||||
<module name="FileTabCharacter">
|
||||
<property name="eachLine" value="true"/>
|
||||
</module>
|
||||
|
||||
<module name="TreeWalker">
|
||||
<module name="OuterTypeFilename"/>
|
||||
<module name="IllegalTokenText">
|
||||
<property name="tokens" value="STRING_LITERAL, CHAR_LITERAL"/>
|
||||
<property name="format"
|
||||
value="\\u00(08|09|0(a|A)|0(c|C)|0(d|D)|22|27|5(C|c))|\\(0(10|11|12|14|15|42|47)|134)"/>
|
||||
<property name="message" value="Avoid using corresponding octal or Unicode escape."/>
|
||||
</module>
|
||||
<module name="AvoidEscapedUnicodeCharacters">
|
||||
<property name="allowEscapesForControlCharacters" value="true"/>
|
||||
<property name="allowByTailComment" value="true"/>
|
||||
<property name="allowNonPrintableEscapes" value="true"/>
|
||||
</module>
|
||||
<module name="LineLength">
|
||||
<property name="max" value="120"/>
|
||||
<property name="ignorePattern" value="^package.*|^import.*|a href|href|http://|https://|ftp://|throw"/>
|
||||
</module>
|
||||
<module name="AvoidStarImport"/>
|
||||
<module name="NoLineWrap"/>
|
||||
<module name="EmptyBlock">
|
||||
<property name="option" value="TEXT"/>
|
||||
<property name="tokens" value="LITERAL_TRY, LITERAL_FINALLY, LITERAL_IF, LITERAL_ELSE, LITERAL_SWITCH"/>
|
||||
</module>
|
||||
<module name="NeedBraces"/>
|
||||
<module name="LeftCurly">
|
||||
<property name="maxLineLength" value="100"/>
|
||||
</module>
|
||||
<module name="RightCurly"/>
|
||||
<module name="RightCurly">
|
||||
<property name="option" value="alone"/>
|
||||
<property name="tokens"
|
||||
value="CLASS_DEF, METHOD_DEF, CTOR_DEF, LITERAL_FOR, LITERAL_WHILE, LITERAL_DO, STATIC_INIT, INSTANCE_INIT"/>
|
||||
</module>
|
||||
<module name="WhitespaceAround">
|
||||
<property name="allowEmptyConstructors" value="true"/>
|
||||
<property name="allowEmptyMethods" value="true"/>
|
||||
<property name="allowEmptyTypes" value="true"/>
|
||||
<property name="allowEmptyLoops" value="true"/>
|
||||
<message key="ws.notFollowed"
|
||||
value="WhitespaceAround: ''{0}'' is not followed by whitespace. Empty blocks may only be represented as '{}' when not part of a multi-block statement (4.1.3)"/>
|
||||
<message key="ws.notPreceded"
|
||||
value="WhitespaceAround: ''{0}'' is not preceded with whitespace."/>
|
||||
</module>
|
||||
<module name="OneStatementPerLine"/>
|
||||
<module name="MultipleVariableDeclarations"/>
|
||||
<module name="ArrayTypeStyle"/>
|
||||
<module name="MissingSwitchDefault"/>
|
||||
<module name="FallThrough"/>
|
||||
<module name="UpperEll"/>
|
||||
<module name="ModifierOrder"/>
|
||||
<module name="EmptyLineSeparator">
|
||||
<property name="allowNoEmptyLineBetweenFields" value="true"/>
|
||||
</module>
|
||||
<module name="SeparatorWrap">
|
||||
<property name="tokens" value="DOT"/>
|
||||
<property name="option" value="nl"/>
|
||||
</module>
|
||||
<module name="SeparatorWrap">
|
||||
<property name="tokens" value="COMMA"/>
|
||||
<property name="option" value="EOL"/>
|
||||
</module>
|
||||
<module name="PackageName">
|
||||
<property name="format" value="^[a-z]+(\.[a-z][a-z0-9]*)*$"/>
|
||||
<message key="name.invalidPattern"
|
||||
value="Package name ''{0}'' must match pattern ''{1}''."/>
|
||||
</module>
|
||||
<module name="TypeName">
|
||||
<message key="name.invalidPattern"
|
||||
value="Type name ''{0}'' must match pattern ''{1}''."/>
|
||||
</module>
|
||||
<module name="MemberName">
|
||||
<property name="format" value="^[a-z][a-z0-9][a-zA-Z0-9]*$"/>
|
||||
<message key="name.invalidPattern"
|
||||
value="Member name ''{0}'' must match pattern ''{1}''."/>
|
||||
</module>
|
||||
<module name="ParameterName">
|
||||
<property name="format" value="^[a-z][a-z0-9][a-zA-Z0-9]*$"/>
|
||||
<message key="name.invalidPattern"
|
||||
value="Parameter name ''{0}'' must match pattern ''{1}''."/>
|
||||
</module>
|
||||
<module name="LocalVariableName">
|
||||
<property name="tokens" value="VARIABLE_DEF"/>
|
||||
<property name="format" value="^[a-z][a-z0-9][a-zA-Z0-9]*$"/>
|
||||
<property name="allowOneCharVarInForLoop" value="true"/>
|
||||
<message key="name.invalidPattern"
|
||||
value="Local variable name ''{0}'' must match pattern ''{1}''."/>
|
||||
</module>
|
||||
<module name="ClassTypeParameterName">
|
||||
<property name="format" value="(^[A-Z][0-9]?)$|([A-Z][a-zA-Z0-9]*[T]$)"/>
|
||||
<message key="name.invalidPattern"
|
||||
value="Class type name ''{0}'' must match pattern ''{1}''."/>
|
||||
</module>
|
||||
<module name="MethodTypeParameterName">
|
||||
<property name="format" value="(^[A-Z][0-9]?)$|([A-Z][a-zA-Z0-9]*[T]$)"/>
|
||||
<message key="name.invalidPattern"
|
||||
value="Method type name ''{0}'' must match pattern ''{1}''."/>
|
||||
</module>
|
||||
<module name="InterfaceTypeParameterName">
|
||||
<property name="format" value="(^[A-Z][0-9]?)$|([A-Z][a-zA-Z0-9]*[T]$)"/>
|
||||
<message key="name.invalidPattern"
|
||||
value="Interface type name ''{0}'' must match pattern ''{1}''."/>
|
||||
</module>
|
||||
<module name="NoFinalizer"/>
|
||||
<module name="GenericWhitespace">
|
||||
<message key="ws.followed"
|
||||
value="GenericWhitespace ''{0}'' is followed by whitespace."/>
|
||||
<message key="ws.preceded"
|
||||
value="GenericWhitespace ''{0}'' is preceded with whitespace."/>
|
||||
<message key="ws.illegalFollow"
|
||||
value="GenericWhitespace ''{0}'' should followed by whitespace."/>
|
||||
<message key="ws.notPreceded"
|
||||
value="GenericWhitespace ''{0}'' is not preceded with whitespace."/>
|
||||
</module>
|
||||
<module name="Indentation">
|
||||
<property name="basicOffset" value="4"/>
|
||||
<property name="braceAdjustment" value="0"/>
|
||||
<property name="caseIndent" value="4"/>
|
||||
<property name="throwsIndent" value="8"/>
|
||||
<property name="lineWrappingIndentation" value="8"/>
|
||||
<property name="arrayInitIndent" value="4"/>
|
||||
</module>
|
||||
<module name="AbbreviationAsWordInName">
|
||||
<property name="ignoreFinal" value="false"/>
|
||||
<property name="allowedAbbreviationLength" value="1"/>
|
||||
</module>
|
||||
<module name="OverloadMethodsDeclarationOrder"/>
|
||||
<module name="VariableDeclarationUsageDistance"/>
|
||||
<module name="CustomImportOrder">
|
||||
<!--<property name="specialsRegExp" value="com.google"/>-->
|
||||
<!--<property name="sortImportsInGroupAlphabetically" value="true"/>-->
|
||||
<!--<property name="customImportOrderRules" value="STATIC###SPECIAL_IMPORTS###THIRD_PARTY_PACKAGE###STANDARD_JAVA_PACKAGE"/>-->
|
||||
</module>
|
||||
<module name="MethodParamPad"/>
|
||||
<module name="OperatorWrap">
|
||||
<property name="option" value="eol"/>
|
||||
<property name="tokens"
|
||||
value="BAND, BOR, BSR, BXOR, DIV, EQUAL, GE, GT, LAND, LE, LITERAL_INSTANCEOF, LOR, LT, MINUS, MOD, NOT_EQUAL, PLUS, QUESTION, SL, SR, STAR "/>
|
||||
</module>
|
||||
<module name="AnnotationLocation">
|
||||
<property name="tokens" value="CLASS_DEF, INTERFACE_DEF, ENUM_DEF, METHOD_DEF, CTOR_DEF"/>
|
||||
</module>
|
||||
<module name="AnnotationLocation">
|
||||
<property name="tokens" value="VARIABLE_DEF"/>
|
||||
<property name="allowSamelineMultipleAnnotations" value="true"/>
|
||||
</module>
|
||||
<module name="NonEmptyAtclauseDescription"/>
|
||||
<module name="AtclauseOrder">
|
||||
<property name="tagOrder" value="@param, @return, @throws, @deprecated"/>
|
||||
<property name="target" value="CLASS_DEF, INTERFACE_DEF, ENUM_DEF, METHOD_DEF, CTOR_DEF, VARIABLE_DEF"/>
|
||||
</module>
|
||||
<module name="MethodName">
|
||||
<property name="format" value="^[a-z][a-z0-9][a-zA-Z0-9_]*$"/>
|
||||
<message key="name.invalidPattern"
|
||||
value="Method name ''{0}'' must match pattern ''{1}''."/>
|
||||
</module>
|
||||
<module name="EmptyCatchBlock">
|
||||
<property name="exceptionVariableName" value="expected"/>
|
||||
</module>
|
||||
|
||||
<module name="DescendantToken">
|
||||
<property name="tokens" value="METHOD_CALL"/>
|
||||
<property name="limitedTokens" value="METHOD_DEF"/>
|
||||
<property name="maximumNumber" value="0"/>
|
||||
<property name="maximumMessage" value="Use Java 8 Lambdas!"/>
|
||||
</module>
|
||||
</module>
|
||||
</module>
|
||||
|
|
@ -0,0 +1,7 @@
|
|||
log4j.debug=false
|
||||
log4j.rootLogger=INFO, CONSOLE
|
||||
log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender
|
||||
log4j.appender.CONSOLE.encoding=UTF-8
|
||||
log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout
|
||||
log4j.appender.CONSOLE.layout.ConversionPattern=%d{ISO8601} [%-5p][%-16.16t][%32.32c] - %m%n
|
||||
log4j.logger.xyz.enhorse=INFO
|
||||
|
|
@ -0,0 +1,238 @@
|
|||
[Вопросы для собеседования на Java Junior](README.md)
|
||||
|
||||
#Основы HTML
|
||||
+ [Что такое _«HTML»_?](#Что-такое-html)
|
||||
+ [Что такое _«XHTML»_?](#Что-такое-xhtml)
|
||||
+ [Что такое `DOCTYPE` и зачем он нужен?](#Что-такое-doctype-и-зачем-он-нужен)
|
||||
+ [Для чего предназначен тег `<head>`?](#Для-чего-предназначен-тег-head)
|
||||
+ [Чем отличается `<div>` от `<span>`?](#Чем-отличается-div-от-span)
|
||||
+ [Как обозначаются комментарии в HTML?](#Как-обозначаются-комментарии-в-html)
|
||||
+ [Каким образом задаётся адрес документа, на который следует перейти?](#Каким-образом-задаётся-адрес-документа-на-который-следует-перейти)
|
||||
+ [Как сделать ссылку на адрес электронной почты?](#Как-сделать-ссылку-на-адрес-электронной-почты)
|
||||
+ [Для чего предназначен тег `<em>`?](#Для-чего-предназначен-тег-em)
|
||||
+ [Для чего предназначены теги `<ol>`, `<ul>`, `<li>`?](#Для-чего-предназначены-теги-ol-ul-li)
|
||||
+ [Для чего предназначены теги `<dl>`, `<dt>`, `<dd>`?](#Для-чего-предназначены-теги-dl-dt-dd)
|
||||
+ [Для чего предназначены теги `<tr>`, `<th>`, `<td>`?](#Для-чего-предназначены-теги-tr-th-td)
|
||||
+ [Обязательно ли писать атрибут `alt` в теге `<img>`?](#Обязательно-ли-писать-атрибут-alt-в-теге-img)
|
||||
+ [В каком регистре лучше писать HTML-код?](#В-каком-регистре-лучше-писать-html-код)
|
||||
+ [Что такое «мнемоника (entity)»?](#Что-такое-мнемоника-entity)
|
||||
|
||||
##Что такое _«HTML»_?
|
||||
__HTML__, HyperText Markup Language («язык гипертекстовой разметки») — стандартизированный язык разметки документов в WWW. На данный момент актуальна 5 версия этого языка - HTML5.
|
||||
|
||||
[к оглавлению](#Основы-html)
|
||||
|
||||
##Что такое _«XHTML»_?
|
||||
__XHTML__, eXtensible HyperText Markup Language («расширяемый язык гипертекстовой разметки») - более строгий вариант HTML, следующий всем ограничениям XML и, фактически являющийся приложением языка XML к области разметки гипертекста.
|
||||
|
||||
[к оглавлению](#Основы-html)
|
||||
|
||||
##Что такое `DOCTYPE` и зачем он нужен?
|
||||
Элемент `<!DOCTYPE>` предназначен для указания типа текущего документа. Это необходимо, чтобы браузер понимал согласно какого стандарта необходимо интерпретировать данную web-страницу.
|
||||
|
||||
Существует несколько видов `<!DOCTYPE>`, различающихся версией языка, на который они ориентированы:
|
||||
|
||||
__HTML 4.01__
|
||||
|
||||
+ `<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"
|
||||
"http://www.w3.org/TR/html4/strict.dtd">`: строгий синтаксис HTML;
|
||||
|
||||
+ `<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
|
||||
"http://www.w3.org/TR/html4/loose.dtd">`: переходный синтаксис HTML;
|
||||
|
||||
+ `<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Frameset//EN"
|
||||
"http://www.w3.org/TR/html4/frameset.dtd">`: HTML с фреймами.
|
||||
|
||||
__HTML 5__
|
||||
|
||||
+ `<!DOCTYPE html>`: для всех документов.
|
||||
|
||||
__XHTML 1.0__
|
||||
|
||||
+ `<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
|
||||
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">`: строгий синтаксис XHTML;
|
||||
|
||||
+ `<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
|
||||
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">`: переходный синтаксис XHTML;
|
||||
|
||||
+ `<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Frameset//EN"
|
||||
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-frameset.dtd">`: XHTML с фреймами.
|
||||
|
||||
__XHTML 1.1__
|
||||
|
||||
+ `<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
|
||||
"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">`: для всех документов.
|
||||
|
||||
[к оглавлению](#Основы-html)
|
||||
|
||||
##Для чего предназначен тег `<head>`?
|
||||
Тег `<head>` предназначен для хранения других элементов, цель которых — помочь браузеру в работе с данными. Также внутри этого контейнера находятся _метатеги_, которые используются для хранения информации предназначенной для браузеров и поисковых систем. Например, механизмы поисковых систем обращаются к метатегам для получения описания сайта, ключевых слов и других данных.
|
||||
|
||||
Содержимое тега `<head>` не отображается напрямую на web-странице, за исключением тега `<title>` устанавливающего заголовок окна.
|
||||
|
||||
Внутри контейнера `<head>` допускается размещать следующие элементы: `<base>`, `<basefont>`, `<bgsound>`, `<link>`, `<meta>`, `<script>`, `<style>`, `<title>`.
|
||||
|
||||
Синтаксис:
|
||||
|
||||
```html
|
||||
<head>
|
||||
...
|
||||
</head>
|
||||
```
|
||||
|
||||
Специфические атрибуты:
|
||||
|
||||
+ `profile`: указывает адрес профиля метаданных.
|
||||
|
||||
[к оглавлению](#Основы-html)
|
||||
|
||||
##Чем отличается `<div>` от `<span>`?
|
||||
`<div>` - блочный, а `<span>` - строчный элементы. Поэтому `<div>` формирует блок из того, что в нем располагается с новой строки, а `<span>` не переносит элементы, размещая их в строку. Так же стоит отметь, что согласно рекомендациям w3c линейный тег не может включать в себя блочные теги, поэтому `<div>` обычно используется для разметки блоков, а `<span>` - отрывков текста.
|
||||
|
||||
[к оглавлению](#Основы-html)
|
||||
|
||||
##Как обозначаются комментарии в HTML?
|
||||
Комментарий в HTML-коде задаётся так: `<!-- комментарий -->`
|
||||
|
||||
Комментарии можно использовать в любом месте страницы, кроме тега `<title>` — внутри него они не работают. Внутри тега `<style>` HTML-комментарии тоже не работают, так как в CSS код комментируется другим способом.
|
||||
|
||||
[к оглавлению](#Основы-html)
|
||||
|
||||
##Каким образом задаётся адрес документа, на который следует перейти?
|
||||
Для создания ссылок на другие документы используется тег `<a>`. В зависимости от присутствия атрибутов `name` или `href` тег `<a>` устанавливает ссылку или якорь. Якорем называется закладка внутри страницы, которую можно указать в качестве цели ссылки. При использовании ссылки, которая указывает на якорь, происходит переход к закладке внутри web-страницы.
|
||||
|
||||
Синтаксис:
|
||||
|
||||
+ `<a href="URL">...</a>`
|
||||
+ `<a name="идентификатор">...</a>`
|
||||
|
||||
Специфические атрибуты:
|
||||
|
||||
+ `accesskey`: активация ссылки с помощью комбинации клавиш;
|
||||
+ `coords`: устанавливает координаты активной области;
|
||||
+ `download`: предлагает скачать указанный по ссылке файл;
|
||||
+ `href`: задает адрес документа, на который следует перейти. Адрес ссылки может быть абсолютным и относительным. Абсолютные адреса работают везде и всюду независимо от имени сайта или веб-страницы, где прописана ссылка. Относительные ссылки, как следует из их названия, построены относительно текущего документа или корня сайта;
|
||||
+ `hreflang`: идентифицирует язык текста по ссылке;
|
||||
+ `name`: устанавливает имя якоря внутри документа;
|
||||
+ `rel`: отношения между ссылаемым и текущим документами;
|
||||
+ `rev`: отношения между текущим и ссылаемым документами;
|
||||
+ `shape`: задает форму активной области ссылки для изображений;
|
||||
+ `tabindex`: определяет последовательность перехода между ссылками при нажатии на кнопку <kbd>Tab</kbd>;
|
||||
+ `target`: имя окна или фрейма, куда браузер будет загружать документ;
|
||||
+ `title`: добавляет всплывающую подсказку к тексту ссылки;
|
||||
+ `type`: указывает MIME-тип документа, на который ведёт ссылка.
|
||||
|
||||
[к оглавлению](#Основы-html)
|
||||
|
||||
##Как сделать ссылку на адрес электронной почты?
|
||||
Создание ссылки на адрес электронной почты делается почти также, как и ссылка на web-страницу. Только вместо URL указывается `mailto:"адрес электронной почты"`
|
||||
|
||||
```html
|
||||
<a href="mailto:user@address.net">Напиши мне!</a>
|
||||
```
|
||||
|
||||
[к оглавлению](#Основы-html)
|
||||
|
||||
##Для чего предназначен тег `<em>`?
|
||||
Тег `<em>` предназначен для акцентирования текста. Браузеры отображают такой текст курсивным начертанием.
|
||||
|
||||
```html
|
||||
<em>Текст</em>
|
||||
```
|
||||
|
||||
[к оглавлению](#Основы-html)
|
||||
|
||||
|
||||
##Для чего предназначены теги `<ol>`, `<ul>`, `<li>`?
|
||||
Теги `<ol>`, `<ul>` и `<li>` предназначены для оформления списков.
|
||||
|
||||
+ `<ol>`: нумерованный список, т.е. каждый элемент списка начинается с числа или буквы и увеличивается по нарастающей.
|
||||
+ `<ul>`: маркированный список, каждый элемент которого начинается с небольшого символа — маркера.
|
||||
+ `<li>`: отдельный элемент списка. Внешний тег `<ul>` или `<ol>` устанавливает тип списка — маркированный или нумерованный.
|
||||
|
||||
```html
|
||||
<ol>Нумерованый список
|
||||
<li>первый</li>
|
||||
<li>второй</li>
|
||||
<li>третий</li>
|
||||
</ol>
|
||||
|
||||
<ul>Маркированный список
|
||||
<li>первый</li>
|
||||
<li>второй</li>
|
||||
<li>третий</li>
|
||||
</ul>
|
||||
```
|
||||
|
||||
[к оглавлению](#Основы-html)
|
||||
|
||||
|
||||
##Для чего предназначены теги `<dl>`, `<dt>`, `<dd>`?
|
||||
Теги `<dl>`, `<dt>`, `<dd>` предназначены для создания списка определений.
|
||||
|
||||
Каждый такой список начинается с контейнера `<dl>`, куда входит тег `<dt>` создающий термин и тег `<dd>` задающий определение этого термина. Закрывающий тег `</dd>` не обязателен, поскольку следующий тег сообщает о завершении предыдущего элемента. Тем не менее, хорошим стилем является закрывать все теги.
|
||||
|
||||
```html
|
||||
<dl>Список определений
|
||||
<dt>Термин</dt>
|
||||
<dd>Определение</dd>
|
||||
</dl>
|
||||
```
|
||||
|
||||
[к оглавлению](#Основы-html)
|
||||
|
||||
##Для чего предназначены теги `<tr>`, `<th>`, `<td>`?
|
||||
|
||||
`<tr>`: служит контейнером для создания строки таблицы. Каждая ячейка в пределах такой строки может задаваться с помощью тега `<th>` или `<td>`.
|
||||
`<th>`: предназначен для создания одной ячейки заголовка таблицы.
|
||||
`<td>`: предназначен для создания одной ячейки таблицы.
|
||||
|
||||
```html
|
||||
<table>
|
||||
<tr>
|
||||
<th>Заголовок</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>Строка</td>
|
||||
</tr>
|
||||
</table>
|
||||
```
|
||||
|
||||
[к оглавлению](#Основы-html)
|
||||
|
||||
##Обязательно ли писать атрибут `alt` в теге `<img>`?
|
||||
Да, писать его обязательно.
|
||||
|
||||
Атрибут `alt` устанавливает альтернативный текст для изображений. Такой текст позволяет получить текстовую информацию о рисунке при отключенной в браузере загрузке изображений. Поскольку загрузка изображений происходит после получения браузером информации о нем, то замещающий рисунок текст появляется раньше. А уже по мере загрузки текст будет сменяться изображением.
|
||||
|
||||
```html
|
||||
<img src="forest.jpg" alt="Лес">
|
||||
```
|
||||
|
||||
[к оглавлению](#Основы-html)
|
||||
|
||||
##В каком регистре лучше писать HTML-код?
|
||||
Весь HTML-код рекомендуется писать в нижнем регистре: это относится к названиям элементов, названиям атрибутов, значениям атрибутов (кроме текста/`CDATA`), селекторам, свойствам и их значениям (кроме текста).
|
||||
|
||||
Не рекомендуется
|
||||
```html
|
||||
<A HREF="/">Домой</A>
|
||||
```
|
||||
|
||||
Рекомендуется
|
||||
```html
|
||||
<img src="forest.jpg" alt="Лес">
|
||||
```
|
||||
|
||||
[к оглавлению](#Основы-html)
|
||||
|
||||
##Что такое «мнемоника (entity)»?
|
||||
__Мнемоника (entity)__ - это конструкция из символа `&` и буквенного (или цифрового кода) после нее, предназначенная для замещения символов, которые запрещены для использования в HTML в «явном виде».
|
||||
|
||||
># имеет мнемонику `#`
|
||||
|
||||
[к оглавлению](#Основы-html)
|
||||
|
||||
#Источники
|
||||
+ [htmlbook](http://htmlbook.ru/html/)
|
||||
+ [Хабрахабр](https://habrahabr.ru/post/143452/)
|
||||
|
|
@ -0,0 +1,301 @@
|
|||
[Вопросы для собеседования на Java Junior](README.md)
|
||||
|
||||
#Потоки ввода/вывода в Java
|
||||
+ [В чём заключается разница между IO и NIO?](#В-чём-заключается-разница-между-io-и-nio)
|
||||
+ [Какие особенности NIO вы знаете?](#Какие-особенности-nio-вы-знаете)
|
||||
+ [Что такое _«каналы»_?](#Что-такое-каналы)
|
||||
+ [Какие существуют виды потоков ввода/вывода?](#Какие-существуют-виды-потоков-вводавывода)
|
||||
+ [Назовите основные классы потоков ввода/вывода.](#Назовите-основные-классы-потоков-вводавывода)
|
||||
+ [В каких пакетах расположены классы потоков ввода/вывода?](#В-каких-пакетах-расположены-классы-потоков-вводавывода)
|
||||
+ [Какие подклассы класса `InputStream` вы знаете, для чего они предназначены?](#Какие-подклассы-класса-inputstream-вы-знаете-для-чего-они-предназначены)
|
||||
+ [Для чего используется `PushbackInputStream`?](#Для-чего-используется-pushbackinputstream)
|
||||
+ [Для чего используется `SequenceInputStream`?](#Для-чего-используется-sequenceinputstream)
|
||||
+ [Какой класс позволяет читать данные из входного байтового потока в формате примитивных типов данных?](#Какой-класс-позволяет-читать-данные-из-входного-байтового-потока-в-формате-примитивных-типов-данных)
|
||||
+ [Какие подклассы класса `OutputStream` вы знаете, для чего они предназначены?](#Какие-подклассы-класса-outputstream-вы-знаете-для-чего-они-предназначены)
|
||||
+ [Какие подклассы класса `Reader` вы знаете, для чего они предназначены?](#Какие-подклассы-класса-reader-вы-знаете-для-чего-они-предназначены)
|
||||
+ [Какие подклассы класса `Writer` вы знаете, для чего они предназначены?](#Какие-подклассы-класса-writer-вы-знаете-для-чего-они-предназначены)
|
||||
+ [В чем отличие класса `PrintWriter` от `PrintStream`?](#В-чем-отличие-класса-printwriter-от-printstream)
|
||||
+ [Чем отличаются и что общего у `InputStream`, `OutputStream`, `Reader`, `Writer`?](#Чем-отличаются-и-что-общего-у-inputstream-outputstream-reader-writer)
|
||||
+ [Какие классы позволяют преобразовать байтовые потоки в символьные и обратно?](#Какие-классы-позволяют-преобразовать-байтовые-потоки-в-символьные-и-обратно)
|
||||
+ [Какие классы позволяют ускорить чтение/запись за счет использования буфера?](#Какие-классы-позволяют-ускорить-чтениезапись-за-счет-использования-буфера)
|
||||
+ [Какой класс предназначен для работы с элементами файловой системы?](#Какой-класс-предназначен-для-работы-с-элементами-файловой-системы)
|
||||
+ [Какие методы класса `File` вы знаете?](#Какие-методы-класса-file-вы-знаете)
|
||||
+ [Что вы знаете об интерфейсе `FileFilter`?](#Что-вы-знаете-об-интерфейсе-filefilter)
|
||||
+ [Как выбрать все элементы определенного каталога по критерию (например, с определенным расширением)?](#Как-выбрать-все-элементы-определенного-каталога-по-критерию-например-с-определенным-расширением)
|
||||
+ [Что вы знаете о `RandomAccessFile`?](#Что-вы-знаете-о-randomaccessfile)
|
||||
+ [Какие режимы доступа к файлу есть у `RandomAccessFile`?](#Какие-режимы-доступа-к-файлу-есть-у-randomaccessfile)
|
||||
+ [Какие классы поддерживают чтение и запись потоков в компрессированном формате?](#Какие-классы-поддерживают-чтение-и-запись-потоков-в-компрессированном-формате)
|
||||
+ [Существует ли возможность перенаправить потоки стандартного ввода/вывода?](#Существует-ли-возможность-перенаправить-потоки-стандартного-вводавывода)
|
||||
+ [Какой символ является разделителем при указании пути в файловой системе?](#Какой-символ-является-разделителем-при-указании-пути-в-файловой-системе)
|
||||
+ [Что такое _«абсолютный путь»_ и _«относительный путь»_?](#Что-такое-абсолютный-путь-и-относительный-путь)
|
||||
+ [Что такое _«символьная ссылка»_?](#Что-такое-символьная-ссылка)
|
||||
|
||||
[к оглавлению](#Потоки-вводавывода-в-java)
|
||||
|
||||
##В чём заключается разница между IO и NIO?
|
||||
+ Java IO (input-output) является потокоориентированным, а Java NIO (new/non-blocking io) – буфер-ориентированным. Потокоориентированный ввод/вывод подразумевает чтение/запись из потока/в поток одного или нескольких байт в единицу времени поочередно. Данная информация нигде не кэшируются. Таким образом, невозможно произвольно двигаться по потоку данных вперед или назад. В Java NIO данные сначала считываются в буфер, что дает больше гибкости при обработке данных.
|
||||
+ Потоки ввода/вывода в Java IO являются блокирующими. Это значит, что когда в потоке выполнения вызывается `read()` или `write()` метод любого класса из пакета `java.io.*`, происходит блокировка до тех пор, пока данные не будут считаны или записаны. Поток выполнения в данный момент не может делать ничего другого. Неблокирующий режим Java NIO позволяет запрашивать считанные данные из канала (channel) и получать только то, что доступно на данный момент, или вообще ничего, если доступных данных пока нет. Вместо того, чтобы оставаться заблокированным пока данные не станут доступными для считывания, поток выполнения может заняться чем-то другим. Тоже самое справедливо и для неблокирующего вывода. Поток выполнения может запросить запись в канал некоторых данных, но не дожидаться при этом пока они не будут полностью записаны.
|
||||
+ В Java NIO имеются селекторы, которые позволяют одному потоку выполнения мониторить несколько каналов ввода. Т.е. существует возможность зарегистрировать несколько каналов с селектором, а потом использовать один поток выполнения для обслуживания каналов, имеющих доступные для обработки данные, или для выбора каналов, готовых для записи.
|
||||
|
||||
[к оглавлению](#Потоки-вводавывода-в-java)
|
||||
|
||||
##Какие особенности NIO вы знаете?
|
||||
+ __Каналы и селекторы__: NIO поддерживает различные типы каналов. Канал является абстракцией объектов более низкого уровня файловой системы (например, отображенные в памяти файлы и блокировки файлов), что позволяет передавать данные с более высокой скоростью. Каналы не блокируются и поэтому Java предоставляет еще такие инструменты, как селектор, который позволяет выбрать готовый канал для передачи данных, и сокет, который является инструментом для блокировки.
|
||||
+ __Буферы__: имеет буферизация для всех классов-обёрток примитивов (кроме Boolean). Появился абстрактный класс Buffer, который предоставляет такие операции, как clear, flip, mark и т.д. Его подклассы предоставляют методы для получения и установки данных.
|
||||
+ __Кодировки__: появились кодеры и декодеры для отображения байт и символов Unicode.
|
||||
[к оглавлению](#Потоки-вводавывода-в-java)
|
||||
|
||||
##Что такое _«каналы»_?
|
||||
Каналы (channels) – это логические (не физические) порталы, абстракции объектов более низкого уровня файловой системы (например, отображенные в памяти файлы и блокировки файлов), через которые осуществляется ввод/вывод данных, а буферы являются источниками или приёмниками этих переданных данных. При организации вывода, данные, которые необходимо отправить, помещаются в буфер, который затем передается в канал. При вводе, данные из канала помещаются в заранее предоставленный буфер.
|
||||
|
||||
Каналы напоминают трубопроводы, по которым эффективно транспортируются данные между буферами байтов и сущностями по ту сторону каналов. Каналы – это шлюзы, которые позволяют получить доступ к сервисам ввода/вывода операционной системы с минимальными накладными расходами, а буферы – внутренние конечные точки этих шлюзов, используемые для передачи и приема данных.
|
||||
|
||||
[к оглавлению](#Потоки-вводавывода-в-java)
|
||||
|
||||
##Какие существуют виды потоков ввода/вывода?
|
||||
##Назовите основные классы потоков ввода/вывода.
|
||||
Разделяют два вида потоков ввода/вывода:
|
||||
|
||||
+ __байтовые__ - `java.io.InputStream`, `java.io.OutputStream`;
|
||||
+ __символьные__ - `java.io.Reader`, `java.io.Writer`.
|
||||
|
||||
[к оглавлению](#Потоки-вводавывода-в-java)
|
||||
|
||||
##В каких пакетах расположены классы потоков ввода/вывода?
|
||||
`java.io`, `java.nio`. Для работы с потоками компрессированных данных используются классы из пакета `java.util.zip`
|
||||
|
||||
[к оглавлению](#Потоки-вводавывода-в-java)
|
||||
|
||||
##Какие подклассы класса `InputStream` вы знаете, для чего они предназначены?
|
||||
+ `InputStream` - абстрактный класс, описывающий поток ввода;
|
||||
+ `BufferedInputStream` - буферизованный входной поток;
|
||||
+ `ByteArrayInputStream` позволяет использовать буфер в памяти (массив байтов) в качестве источника данных для входного потока;
|
||||
+ `DataInputStream` - входной поток для байтовых данных, включающий методы для чтения стандартных типов данных Java;
|
||||
+ `FileInputStream` - входной поток для чтения информации из файла;
|
||||
+ `FilterInputStream` - абстрактный класс, предоставляющий интерфейс для классов-надстроек, которые добавляют к существующим потокам полезные свойства;
|
||||
+ `ObjectInputStream` - входной поток для объектов;
|
||||
+ `StringBufferInputStream` превращает строку (`String`) во входной поток данных `InputStream`;
|
||||
+ `PipedInputStream` реализует понятие входного канала;
|
||||
+ `PrintStream` - выходной поток, включающий методы `print()` и `println()`;
|
||||
+ PushbackInputStream - разновидность буферизации, обеспечивающая чтение байта с последующим его возвратом в поток, позволяет «заглянуть» во входной поток и увидеть, что оттуда поступит в следующий момент, не извлекая информации.
|
||||
+ `SequenceInputStream` используется для слияния двух или более потоков `InputStream` в единый.
|
||||
|
||||
[к оглавлению](#Потоки-вводавывода-в-java)
|
||||
|
||||
##Для чего используется `PushbackInputStream`?
|
||||
Разновидность буферизации, обеспечивающая чтение байта с последующим его возвратом в поток. Класс `PushbackInputStream` представляет механизм «заглянуть» во входной поток и увидеть, что оттуда поступит в следующий момент, не извлекая информации.
|
||||
|
||||
У класса есть дополнительный метод unread().
|
||||
|
||||
[к оглавлению](#Потоки-вводавывода-в-java)
|
||||
|
||||
##Для чего используется `SequenceInputStream`?
|
||||
Класс `SequenceInputStream` позволяет сливать вместе несколько экземпляров класса `InputStream`. Конструктор принимает в качестве аргумента либо пару объектов класса `InputStream`, либо интерфейс `Enumeration`.
|
||||
|
||||
Во время работы класс выполняет запросы на чтение из первого объекта класса `InputStream` и до конца, а затем переключается на второй. При использовании интерфейса работа продолжится по всем объектам класса `InputStream`. По достижении конца, связанный с ним поток закрывается. Закрытие потока, созданного объектом класса `SequenceInputStream`, приводит к закрытию всех открытых потоков.
|
||||
|
||||
[к оглавлению](#Потоки-вводавывода-в-java)
|
||||
|
||||
##Какой класс позволяет читать данные из входного байтового потока в формате примитивных типов данных?
|
||||
Класс `DataInputStream` представляет поток ввода и предназначен для записи данных примитивных типов, таких, как `int`, `double` и т.д. Для каждого примитивного типа определен свой метод для считывания:
|
||||
|
||||
+ `boolean readBoolean()`: считывает из потока булевое однобайтовое значение
|
||||
+ `byte readByte()`: считывает из потока 1 байт
|
||||
+ `char readChar()`: считывает из потока значение `char`
|
||||
+ `double readDouble()`: считывает из потока 8-байтовое значение `double`
|
||||
+ `float readFloat()`: считывает из потока 4-байтовое значение `float`
|
||||
+ `int readInt()`: считывает из потока целочисленное значение `int`
|
||||
+ `long readLong()`: считывает из потока значение `long`
|
||||
+ `short readShort()`: считывает значение `short`
|
||||
+ `String readUTF()`: считывает из потока строку в кодировке UTF-8
|
||||
|
||||
[к оглавлению](#Потоки-вводавывода-в-java)
|
||||
|
||||
##Какие подклассы класса `OutputStream` вы знаете, для чего они предназначены?
|
||||
+ `OutputStream` - это абстрактный класс, определяющий потоковый байтовый вывод;
|
||||
+ `BufferedOutputStream` - буферизированный выходной поток;
|
||||
+ `ByteArrayOutputStream` - все данные, посылаемые в этот поток, размещаются в предварительно созданном буфере;
|
||||
+ `DataOutputStream` - выходной поток байт, включающий методы для записи стандартных типов данных Java;
|
||||
+ `FileOutputStream` - запись данных в файл на физическом носителе;
|
||||
+ `FilterOutputStream` - абстрактный класс, предоставляющий интерфейс для классов-надстроек, которые добавляют к существующим потокам полезные свойства;
|
||||
+ `ObjectOutputStream` - выходной поток для записи объектов;
|
||||
+ `PipedOutputStream` реализует понятие выходного канала.
|
||||
|
||||
[к оглавлению](#Потоки-вводавывода-в-java)
|
||||
|
||||
##Какие подклассы класса `Reader` вы знаете, для чего они предназначены?
|
||||
+ `Reader` - абстрактный класс, описывающий символьный ввод;
|
||||
+ `BufferedReader` - буферизованный входной символьный поток;
|
||||
+ `CharArrayReader` - входной поток, который читает из символьного массива;
|
||||
+ `FileReader` - входной поток, читающий файл;
|
||||
+ `FilterReader` - абстрактный класс, предоставляющий интерфейс для классов-надстроек;
|
||||
+ `InputStreamReader`- входной поток, транслирующий байты в символы;
|
||||
+ `LineNumberReader` - входной поток, подсчитывающий строки;
|
||||
+ `PipedReader` - входной канал;
|
||||
+ `PushbackReader` - входной поток, позволяющий возвращать символы обратно в поток;
|
||||
+ `StringReader` - входной поток, читающий из строки.
|
||||
|
||||
[к оглавлению](#Потоки-вводавывода-в-java)
|
||||
|
||||
##Какие подклассы класса `Writer` вы знаете, для чего они предназначены?
|
||||
+ `Writer` - абстрактный класс, описывающий символьный вывод;
|
||||
+ `BufferedWriter` - буферизованный выходной символьный поток;
|
||||
+ `CharArrayWriter` - выходной поток, который пишет в символьный массив;
|
||||
+ `FileWriter` - выходной поток, пишущий в файл;
|
||||
+ `FilterWriter` - абстрактный класс, предоставляющий интерфейс для классов-надстроек;
|
||||
+ `OutputStreamWriter` - выходной поток, транслирующий байты в символы;
|
||||
+ `PipedWriter` - выходной канал;
|
||||
+ `PrintWriter` - выходной поток символов, включающий методы `print()` и `println()`;
|
||||
+ `StringWriter` - выходной поток, пишущий в строку;
|
||||
|
||||
[к оглавлению](#Потоки-вводавывода-в-java)
|
||||
|
||||
##В чем отличие класса `PrintWriter` от `PrintStream`?
|
||||
Прежде всего, в классе `PrintWriter` применен усовершенствованный способ работы с символами Unicode и другой механизм буферизации вывода: в классе PrintStream буфер вывода сбрасывался всякий раз, когда вызывался метод `print()` или `println()`, а при использовании класса `PrintWriter` существует возможность отказаться от автоматического сброса буферов, выполняя его явным образом при помощи метода `flush()`.
|
||||
|
||||
Кроме того, методы класса `PrintWriter` никогда не создают исключений. Для проверки ошибок необходимо явно вызвать метод `checkError()`.
|
||||
|
||||
[к оглавлению](#Потоки-вводавывода-в-java)
|
||||
|
||||
##Чем отличаются и что общего у `InputStream`, `OutputStream`, `Reader`, `Writer`?
|
||||
+ `InputStream` и его наследники - совокупность для получения байтовых данных из различных источников;
|
||||
+ `OutputStream` и его наследники - набор классов определяющих потоковый байтовый вывод;
|
||||
+ `Reader` и его наследники определяют потоковый ввод символов Unicode;
|
||||
+ `Writer` и его наследники определяют потоковый вывод символов Unicode.
|
||||
|
||||
[к оглавлению](#Потоки-вводавывода-в-java)
|
||||
|
||||
##Какие классы позволяют преобразовать байтовые потоки в символьные и обратно?
|
||||
+ `OutputStreamWriter` — «мост» между классом `OutputStream` и классом `Writer`. Символы, записанные в поток, преобразовываются в байты.
|
||||
+ `InputStreamReader` — аналог для чтения. При помощи методов класса `Reader` читаются байты из потока `InputStream` и далее преобразуются в символы.
|
||||
|
||||
[к оглавлению](#Потоки-вводавывода-в-java)
|
||||
|
||||
##Какие классы позволяют ускорить чтение/запись за счет использования буфера?
|
||||
+ `BufferedInputStream(InputStream in)`/`BufferedInputStream(InputStream in, int size)`,
|
||||
+ `BufferedOutputStream(OutputStream out)`/`BufferedOutputStream(OutputStream out, int size)`,
|
||||
+ `BufferedReader(Reader r)`/`BufferedReader(Reader in, int sz)`,
|
||||
+ `BufferedWriter(Writer out)`/`BufferedWriter(Writer out, int sz)`
|
||||
|
||||
[к оглавлению](#Потоки-вводавывода-в-java)
|
||||
|
||||
##Какой класс предназначен для работы с элементами файловой системы?
|
||||
`File` работает непосредственно с файлами и каталогами. Данный класс позволяет создавать новые элементы и получать информацию существующих: размер, права доступа, время и дату создания, путь к родительскому каталогу.
|
||||
|
||||
[к оглавлению](#Потоки-вводавывода-в-java)
|
||||
|
||||
##Какие методы класса `File` вы знаете?
|
||||
Наиболее используемые методы класса `File`:
|
||||
|
||||
+ `boolean createNewFile()`: делает попытку создать новый файл;
|
||||
+ `boolean delete()`: делает попытку удалить каталог или файл;
|
||||
+ `boolean mkdir()`: делает попытку создать новый каталог;
|
||||
+ `boolean renameTo(File dest)`: делает попытку переименовать файл или каталог;
|
||||
+ `boolean exists()`: проверяет, существует ли файл или каталог;
|
||||
+ `String getAbsolutePath()`: возвращает абсолютный путь для пути, переданного в конструктор объекта;
|
||||
+ `String getName()`: возвращает краткое имя файла или каталога;
|
||||
+ `String getParent()`: возвращает имя родительского каталога;
|
||||
+ `boolean isDirectory()`: возвращает значение `true`, если по указанному пути располагается каталог;
|
||||
+ `boolean isFile()`: возвращает значение `true`, если по указанному пути находится файл;
|
||||
+ `boolean isHidden()`: возвращает значение `true`, если каталог или файл являются скрытыми;
|
||||
+ `long length()`: возвращает размер файла в байтах;
|
||||
+ `long lastModified()`: возвращает время последнего изменения файла или каталога;
|
||||
+ `String[] list()`: возвращает массив файлов и подкаталогов, которые находятся в определенном каталоге;
|
||||
+ `File[] listFiles()`: возвращает массив файлов и подкаталогов, которые находятся в определенном каталоге.
|
||||
|
||||
[к оглавлению](#Потоки-вводавывода-в-java)
|
||||
|
||||
##Что вы знаете об интерфейсе `FileFilter`?
|
||||
Интерфейс `FileFilter` применяется для проверки, попадает ли объект `File` под некоторое условие. Этот интерфейс содержит единственный метод `boolean accept(File pathName)`. Этот метод необходимо переопределить и реализовать. Например:
|
||||
|
||||
```java
|
||||
public boolean accept(final File file) {
|
||||
return file.isExists() && file.isDirectory();
|
||||
}
|
||||
```
|
||||
|
||||
[к оглавлению](#Потоки-вводавывода-в-java)
|
||||
|
||||
##Как выбрать все элементы определенного каталога по критерию (например, с определенным расширением)?
|
||||
Метод `File.listFiles()` возвращает массив объектов `File`, содержащихся в каталоге. Метод может принимать в качестве параметра объект класса, реализующего `FileFilter`. Это позволяет включить список только те элементы, для которые метода `accept` возвращает `true` (критерием может быть длина имени файла или его расширение).
|
||||
|
||||
[к оглавлению](#Потоки-вводавывода-в-java)
|
||||
|
||||
##Что вы знаете о `RandomAccessFile`?
|
||||
Класс `java.io.RandomAccessFile` обеспечивает чтение и запись данных в произвольном месте файла. Он не является частью иерархии `InputStream` или `OutputStream`. Это полностью отдельный класс, имеющий свои собственные (в большинстве своем _native_) методы. Объяснением этого может быть то, что `RandomAccessFile` имеет во многом отличающееся поведение по сравнению с остальными классами ввода/вывода так как позволяет, в пределах файла, перемещаться вперед и назад.
|
||||
|
||||
`RandomAccessFile` имеет такие специфические методы как:
|
||||
|
||||
+ `getFilePointer()` для определения текущего местоположения в файле;
|
||||
+ `seek()` для перемещения на новую позицию в файле;
|
||||
+ `length()` для выяснения размера файла;
|
||||
+ `setLength()` для установки размера файла;
|
||||
+ `skipBytes()` для того, чтобы попытаться пропустить определённое число байт;
|
||||
+ `getChannel()` для работы с уникальным файловым каналом, ассоциированным с заданным файлом;
|
||||
+ методы для выполнения обычного и форматированного вывода из файла (`read()`, `readInt()`, `readLine()`, `readUTF()` и т.п.);
|
||||
+ методы для обычной или форматированной записи в файл с прямым доступом (`write()`, `writeBoolean()`, `writeByte()` и т.п.).
|
||||
|
||||
Так же следует отметить, что конструкторы `RandomAccessFile` требуют второй аргумент, указывающий необходимый режим доступа к файлу - только чтение (`"r"`), чтение и запись (`"rw"`) или иную их разновидность.
|
||||
|
||||
[к оглавлению](#Потоки-вводавывода-в-java)
|
||||
|
||||
##Какие режимы доступа к файлу есть у `RandomAccessFile`?
|
||||
+ `"r"` открывает файл только для чтения. Запуск любых методов записи данных приведет к выбросу исключения `IOException`.
|
||||
+ `"rw"` открывает файл для чтения и записи. Если файл еще не создан, то осуществляется попытка создать его.
|
||||
+ `"rws"` открывает файл для чтения и записи подобно `"rw"`, но требует от системы при каждом изменении содержимого файла или метаданных синхронно записывать эти изменения на физический носитель.
|
||||
+ `"rwd"` открывает файл для чтения и записи подобно `"rws"`, но требует от системы синхронно записывать изменения на физический носитель только при каждом изменении содержимого файла. Если изменяются метаданные, синхронная запись не требуется.
|
||||
|
||||
[к оглавлению](#Потоки-вводавывода-в-java)
|
||||
|
||||
##Какие классы поддерживают чтение и запись потоков в компрессированном формате?
|
||||
+ `DeflaterOutputStream` - компрессия данных в формате deflate.
|
||||
+ `Deflater` - компрессия данных в формат ZLIB
|
||||
+ `ZipOutputStream` - потомок `DeflaterOutputStream` для компрессии данных в формат Zip.
|
||||
+ `GZIPOutputStream` - потомок `DeflaterOutputStream` для компрессии данных в формат GZIP.
|
||||
+ `InflaterInputStream` - декомпрессия данных в формате deflate.
|
||||
+ `Inflater` - декомпрессия данных в формате ZLIB
|
||||
+ `ZipInputStream` - потомок `InflaterInputStream` для декомпрессии данных в формате Zip.
|
||||
+ `GZIPInputStream` - потомок `InflaterInputStream` для декомпрессии данных в формате GZIP.
|
||||
|
||||
[к оглавлению](#Потоки-вводавывода-в-java)
|
||||
|
||||
##Существует ли возможность перенаправить потоки стандартного ввода/вывода?
|
||||
Класс `System` позволяет вам перенаправлять стандартный ввод, вывод и поток вывода ошибок, используя простой вызов статического метода:
|
||||
|
||||
+ `setIn(InputStream)` - для ввода;
|
||||
+ `setOut(PrintStream)` - для вывода;
|
||||
+ `setErr(PrintStream)` - для вывода ошибок.
|
||||
|
||||
[к оглавлению](#Потоки-вводавывода-в-java)
|
||||
|
||||
##Какой символ является разделителем при указании пути в файловой системе?
|
||||
Для различных операционных систем символ разделителя различается. Для Windows это `\`, для Linux - `/`.
|
||||
|
||||
В Java получить разделитель для текущей операционной системы можно через обращение к статическому полю `File.separator`.
|
||||
|
||||
[к оглавлению](#Потоки-вводавывода-в-java)
|
||||
|
||||
##Что такое _«абсолютный путь»_ и _«относительный путь»_?
|
||||
__Абсолютный (полный) путь__ — это путь, который указывает на одно и то же место в файловой системе, вне зависимости от текущей рабочей директории или других обстоятельств. Полный путь всегда начинается с корневого каталога.
|
||||
|
||||
__Относительный путь__ представляет собой путь по отношению к текущему рабочему каталогу пользователя или активного приложения.
|
||||
|
||||
[к оглавлению](#Потоки-вводавывода-в-java)
|
||||
|
||||
##Что такое _«символьная ссылка»_?
|
||||
__Символьная (символическая) ссылка__ (также «симлинк», Symbolic link) — специальный файл в файловой системе, в котором, вместо пользовательских данных, содержится путь к файлу, который должен быть открыт при попытке обратиться к данной ссылке (файлу). Целью ссылки может быть любой объект: например, другая ссылка, файл, каталог или даже несуществующий файл (в последнем случае, при попытке открыть его, должно выдаваться сообщение об отсутствии файла).
|
||||
|
||||
Символьные ссылки используются для более удобной организации структуры файлов на компьютере, так как:
|
||||
|
||||
+ позволяют для одного файла или каталога иметь несколько имён и различных атрибутов;
|
||||
+ свободны от некоторых ограничений, присущих жёстким ссылкам (последние действуют только в пределах одной файловой системы (одного раздела) и не могут ссылаться на каталоги).
|
||||
|
||||
[к оглавлению](#Потоки-вводавывода-в-java)
|
||||
|
||||
#Источники
|
||||
+ [Quizful](http://www.quizful.net/post/java-nio-tutorial)
|
||||
+ [Хабрахабр](https://habrahabr.ru/post/235585/)
|
||||
+ [Освой программирование играючи](http://developer.alexanderklimov.ru/android/java/io.php)
|
||||
+ [Metanit](http://metanit.com/java/tutorial/6.1.php)
|
||||
+ [javastudy.ru](http://javastudy.ru/interview/input-output/)
|
||||
+ [Bruce Eckel «Thinking in Java»](http://iais.kemsu.ru/odocs/java/Chapter11.html)
|
||||
|
|
@ -0,0 +1,924 @@
|
|||
[Вопросы для собеседования на Java Junior](README.md)
|
||||
|
||||
#Java 8
|
||||
+ [Какие нововведения, появились в Java 8 и JDK 8?](#Какие-нововведения-появились-в-java-8-и-jdk-8)
|
||||
+ [Что такое _«лямбда»_? Какова структура и особенности использования лямбда-выражения?](#Что-такое-лямбда-Какова-структура-и-особенности-использования-лямбда-выражения)
|
||||
+ [К каким переменным есть доступ у лямбда-выражений?](#К-каким-переменным-есть-доступ-у-лямбда-выражений)
|
||||
+ [Как отсортировать список строк с помощью лямбда-выражения?](#Как-отсортировать-список-строк-с-помощью-лямбда-выражения)
|
||||
+ [Что такое «ссылка на метод»?](#Что-такое-ссылка-на-метод)
|
||||
+ [Какие виды ссылок на методы вы знаете?](#Какие-виды-ссылок-на-методы-вы-знаете)
|
||||
+ [Объясните выражение `System.out::println`.](#Объясните-выражение-systemoutprintln)
|
||||
+ [Что такое «функциональные интерфейсы»?](#Что-такое-функциональные-интерфейсы)
|
||||
+ [Для чего нужны функциональные интерфейсы `Function<T,R>`, `DoubleFunction<R>`, `IntFunction<R>` и `LongFunction<R>`?](#Для-чего-нужны-функциональные-интерфейсы-functiontr-doublefunctionr-intfunctionr-и-longfunctionr)
|
||||
+ [Для чего нужны функциональные интерфейсы `UnaryOperator<T>`, `DoubleUnaryOperator`, `IntUnaryOperator` и `LongUnaryOperator`?](#Для-чего-нужны-функциональные-интерфейсы-unaryoperatort-doubleunaryoperator-intunaryoperator-и-longunaryoperator)
|
||||
+ [Для чего нужны функциональные интерфейсы `BinaryOperator<T>`, `DoubleBinaryOperator`, `IntBinaryOperator` и `LongBinaryOperator`?](#Для-чего-нужны-функциональные-интерфейсы-binaryoperatort-doublebinaryoperator-intbinaryoperator-и-longbinaryoperator)
|
||||
+ [Для чего нужны функциональные интерфейсы `Predicate<T>`, `DoublePredicate`, `IntPredicate` и `LongPredicate`?](#Для-чего-нужны-функциональные-интерфейсы-predicatet-doublepredicate-intpredicate-и-longpredicate)
|
||||
+ [Для чего нужны функциональные интерфейсы `Consumer<T>`, `DoubleConsumer`, `IntConsumer` и `LongConsumer`?](#Для-чего-нужны-функциональные-интерфейсы-consumert-doubleconsumer-intconsumer-и-longconsumer)
|
||||
+ [Для чего нужны функциональные интерфейсы `Supplier<T>`, `BooleanSupplier`, `DoubleSupplier`, `IntSupplier` и `LongSupplier`?](#Для-чего-нужны-функциональные-интерфейсы-suppliert--booleansupplier-doublesupplier-intsupplier-и-longsupplier)
|
||||
+ [Для чего нужен функциональный интерфейс `BiConsumer<T,U>`?](#Для-чего-нужен-функциональный-интерфейс-biconsumertu)
|
||||
+ [Для чего нужен функциональный интерфейс `BiFunction<T,U,R>`?](#Для-чего-нужен-функциональный-интерфейс-bifunctiontur)
|
||||
+ [Для чего нужен функциональный интерфейс `BiPredicate<T,U>`?](#Для-чего-нужен-функциональный-интерфейс-bipredicatetu)
|
||||
+ [Для чего нужны функциональные интерфейсы вида `_To_Function`?](#Для-чего-нужны-функциональные-интерфейсы-вида-tofunction)
|
||||
+ [Для чего нужны функциональные интерфейсы `ToDoubleBiFunction<T,U>`, `ToIntBiFunction<T,U>` и `ToLongBiFunction<T,U>`?](#Для-чего-нужны-функциональные-интерфейсы-todoublebifunctiontu-tointbifunctiontu-и-tolongbifunctiontu)
|
||||
+ [Для чего нужны функциональные интерфейсы `ToDoubleFunction<T>`, `ToIntFunction<T>` и `ToLongFunction<T>`?](#Для-чего-нужны-функциональные-интерфейсы-todoublefunctiont-tointfunctiont-и-tolongfunctiont)
|
||||
+ [Для чего нужны функциональные интерфейсы `ObjDoubleConsumer<T>`, `ObjIntConsumer<T>` и `ObjLongConsumer<T>`?](#Для-чего-нужны-функциональные-интерфейсы-objdoubleconsumert-objintconsumert-и-objlongconsumert)
|
||||
+ [Что такое `StringJoiner`?](#Что-такое-stringjoiner)
|
||||
+ [Что такое `default` методы интрефейса?](#Что-такое-default-методы-интрефейса)
|
||||
+ [Как вызывать `default` метод интерфейса в реализующем этот интерфейс классе?](#Как-вызывать-default-метод-интерфейса-в-реализующем-этот-интерфейс-классе)
|
||||
+ [Что такое `static` метод интерфейса?](#Что-такое-static-метод-интерфейса)
|
||||
+ [Как вызывать `static` метод интерфейса?](#Как-вызывать-static-метод-интерфейса)
|
||||
+ [Что такое `Optional`?](#Что-такое-optional)
|
||||
+ [Что такое `Stream`?](#Что-такое-stream)
|
||||
+ [Какие существуют способы создания стрима?](#Какие-существуют-способы-создания-стрима)
|
||||
+ [В чем разница между `Collection` и `Stream`?](#В-чем-разница-между-collection-и-stream)
|
||||
+ [Для чего нужен метод `collect()` в стримах?](#Для-чего-нужен-метод-collect-в-стримах)
|
||||
+ [Для чего в стримах применяются методы `forEach()` и `forEachOrdered()`?](#Для-чего-в-стримах-применяются-методы-foreach-и-foreachordered)
|
||||
+ [Для чего в стримах предназначены методы `map()` и `mapToInt()`, `mapToDouble()`, `mapToLong()`?](#Для-чего-в-стримах-предназначены-методы-map-и-maptoint-maptodouble-maptolong)
|
||||
+ [Какова цель метода `filter()` в стримах?](#Какова-цель-метода-filter-в-стримах)
|
||||
+ [Для чего в стримах предназначен метод `limit()`?](#Для-чего-в-стримах-предназначен-метод-limit)
|
||||
+ [Для чего в стримах предназначен метод `sorted()`?](#Для-чего-в-стримах-предназначен-метод-sorted)
|
||||
+ [Для чего в стримах предназначены методы `flatMap()`, `flatMapToInt()`, `flatMapToDouble()`, `flatMapToLong()`?](#Для-чего-в-стримах-предназначены-методы-flatmap-flatmaptoint-flatmaptodouble-flatmaptolong)
|
||||
+ [Расскажите о параллельной обработке в Java 8.](#Расскажите-о-параллельной-обработке-в-java-8)
|
||||
+ [Какие конечные методы работы со стримами вы знаете?](#Какие-конечные-методы-работы-со-стримами-вы-знаете)
|
||||
+ [Какие промежуточные методы работы со стримами вы знаете?](#Какие-промежуточные-методы-работы-со-стримами-вы-знаете)
|
||||
+ [Как вывести на экран 10 случайных чисел, используя `forEach()`?](#Как-вывести-на-экран-10-случайных-чисел-используя-foreach)
|
||||
+ [Как можно вывести на экран уникальные квадраты чисел используя метод `map()`?](#Как-можно-вывести-на-экран-уникальные-квадраты-чисел-используя-метод-map)
|
||||
+ [Как вывести на экран количество пустых строк с помощью метода `filter()`?](#Как-вывести-на-экран-количество-пустых-строк-с-помощью-метода-filter)
|
||||
+ [Как вывести на экран 10 случайных чисел в порядке возрастания?](#Как-вывести-на-экран-10-случайных-чисел-в-порядке-возрастания)
|
||||
+ [Как найти максимальное число в наборе?](#Как-найти-максимальное-число-в-наборе)
|
||||
+ [Как найти минимальное число в наборе?](#Как-найти-минимальное-число-в-наборе)
|
||||
+ [Как получить сумму всех чисел в наборе?](#Как-получить-сумму-всех-чисел-в-наборе)
|
||||
+ [Как получить среднее значение всех чисел?](#Как-получить-среднее-значение-всех-чисел)
|
||||
+ [Какие дополнительные методы для работы с ассоциативными массивами (maps) появились в Java 8?](#Какие-дополнительные-методы-для-работы-с-ассоциативными-массивами-maps-появились-в-java-8)
|
||||
+ [Что такое `LocalDateTime`?](#Что-такое-localdatetime)
|
||||
+ [Что такое `ZonedDateTime`?](#Что-такое-zoneddatetime)
|
||||
+ [Как получить текущую дату с использованием Date Time API из Java 8?](#Как-получить-текущую-дату-с-использованием-date-time-api-из-java-8)
|
||||
+ [Как добавить 1 неделю, 1 месяц, 1 год, 10 лет к текущей дате с использованием Date Time API?](#Как-добавить-1-неделю-1-месяц-1-год-10-лет-к-текущей-дате-с-использованием-date-time-api)
|
||||
+ [Как получить следующий вторник используя Date Time API?](#Как-получить-следующий-вторник-используя-date-time-api)
|
||||
+ [Как получить вторую субботу текущего месяца используя Date Time API?](#Как-получить-вторую-субботу-текущего-месяца-используя-date-time-api)
|
||||
+ [Как получить текущее время с точностью до миллисекунд используя Date Time API?](#Как-получить-текущее-время-с-точностью-до-миллисекунд-используя-date-time-api)
|
||||
+ [Как получить текущее время по местному времени с точностью до миллисекунд используя Date Time API?](#Как-получить-текущее-время-по-местному-времени-с-точностью-до-миллисекунд-используя-date-time-api)
|
||||
+ [Как определить повторяемую аннотацию?](#Как-определить-повторяемую-аннотацию)
|
||||
+ [Что такое `Nashorn`?](#Что-такое-nashorn)
|
||||
+ [Что такое `jjs`?](#Что-такое-jjs)
|
||||
+ [Какой класс появился в Java 8 для кодирования/декодирования данных?](#Какой-класс-появился-в-java-8-для-кодированиядекодирования-данных)
|
||||
+ [Как создать Base64 кодировщик и декодировщик?](#Как-создать-base64-кодировщик-и-декодировщик)
|
||||
|
||||
##Какие нововведения, появились в Java 8 и JDK 8?
|
||||
+ Методы интерфейсов по умолчанию;
|
||||
+ Лямбда-выражения;
|
||||
+ Функциональные интерфейсы;
|
||||
+ Ссылки на методы и конструкторы;
|
||||
+ Повторяемые аннотации;
|
||||
+ Аннотации на типы данных;
|
||||
+ Рефлексия для параметров методов;
|
||||
+ _Stream API_ для работы с коллекциями;
|
||||
+ Параллельная сортировка массивов;
|
||||
+ Новое API для работы с датами и временем;
|
||||
+ Новый движок JavaScript _Nashorn_;
|
||||
+ Добавлено несколько новых классов для потокобезопасной работы;
|
||||
+ Добавлен новый API для `Calendar` и `Locale`;
|
||||
+ Добавлена поддержка _Unicode 6.2.0_;
|
||||
+ Добавлен стандартный класс для работы с _Base64_;
|
||||
+ Добавлена поддержка беззнаковой арифметики;
|
||||
+ Улучшена производительность конструктора `java.lang.String(byte[], *)` и метода `java.lang.String.getBytes()`;
|
||||
+ Новая реализация `AccessController.doPrivileged`, позволяющая устанавливать подмножество привилегий без необходимости проверки всех остальных уровней доступа;
|
||||
+ _Password-based_ алгоритмы стали более устойчивыми;
|
||||
+ Добавлена поддержка _SSL/TLS Server Name Indication (NSI)_ в _JSSE Server_;
|
||||
+ Улучшено хранилище ключей (KeyStore);
|
||||
+ Добавлен алгоритм _SHA-224_;
|
||||
+ Удален мост _JDBC - ODBC_;
|
||||
+ Удален _PermGen_, изменен способ хранения мета-данных классов;
|
||||
+ Возможность создания профилей для платформы Java SE, которые включают в себя не всю платформу целиком, а некоторую ее часть;
|
||||
+ Инструментарий
|
||||
+ Добавлена утилита `jjs` для использования _JavaScript Nashorn_;
|
||||
+ Команда `java` может запускать _JavaFX_ приложения;
|
||||
+ Добавлена утилита `jdeps` для анализа _.class_-файлов.
|
||||
|
||||
[к оглавлению](#java-8)
|
||||
|
||||
##Что такое _«лямбда»_? Какова структура и особенности использования лямбда-выражения?
|
||||
__Лямбда__ представляет собой набор инструкций, которые можно выделить в отдельную переменную и затем многократно вызвать в различных местах программы.
|
||||
|
||||
Основу лямбда-выражения составляет _лямбда-оператор_, который представляет стрелку `->`. Этот оператор разделяет лямбда-выражение на две части: левая часть содержит список параметров выражения, а правая собственно представляет тело лямбда-выражения, где выполняются все действия.
|
||||
|
||||
Лямбда-выражение не выполняется само по себе, а образует реализацию метода, определенного в функциональном интерфейсе. При этом важно, что функциональный интерфейс должен содержать только один единственный метод без реализации.
|
||||
|
||||
```java
|
||||
interface Operationable {
|
||||
int calculate(int x, int y);
|
||||
}
|
||||
|
||||
public static void main(String[] args) {
|
||||
Operationable operation = (x, y) -> x + y;
|
||||
int result = operation.calculate(10, 20);
|
||||
System.out.println(result); //30
|
||||
}
|
||||
```
|
||||
|
||||
По факту лямбда-выражения являются в некотором роде сокращенной формой внутренних анонимных классов, которые ранее применялись в Java.
|
||||
|
||||
+ _Отложенное выполнение (deferred execution) лямбда-выражения_- определяется один раз в одном месте программы, вызываются при необходимости, любое количество раз и в произвольном месте программы.
|
||||
|
||||
+ _Параметры лямбда-выражения_ должны соответствовать по типу параметрам метода функционального интерфейса:
|
||||
|
||||
```java
|
||||
operation = (int x, int y) -> x + y;
|
||||
//При написании самого лямбда-выражения тип параметров разрешается не указывать:
|
||||
(x, y) -> x + y;
|
||||
//Если метод не принимает никаких параметров, то пишутся пустые скобки, например:
|
||||
() -> 30 + 20;
|
||||
//Если метод принимает только один параметр, то скобки можно опустить:
|
||||
n -> n * n;
|
||||
```
|
||||
|
||||
+ _Конечные лямбда-выражения_ не обязаны возвращать какое-либо значение.
|
||||
|
||||
```java
|
||||
interface Printable {
|
||||
void print(String s);
|
||||
}
|
||||
|
||||
public static void main(String[] args) {
|
||||
Printable printer = s -> System.out.println(s);
|
||||
printer.print("Hello, world");
|
||||
}
|
||||
```java
|
||||
|
||||
+ _Блочные лямбда-выражения_ обрамляются фигурными скобками. В блочных лямбда-выражениях можно использовать внутренние вложенные блоки, циклы, конструкции `if`, `switch`, создавать переменные и т.д. Если блочное лямбда-выражение должно возвращать значение, то явным образом применяется оператор `return`:
|
||||
|
||||
```java
|
||||
Operationable operation = (int x, int y) -> {
|
||||
if (y == 0) {
|
||||
return 0;
|
||||
}
|
||||
else {
|
||||
return x / y;
|
||||
}
|
||||
};
|
||||
```
|
||||
|
||||
+ _Передача лямбда-выражения в качестве параметра метода_:
|
||||
|
||||
```java
|
||||
interface Condition {
|
||||
boolean isAppropriate(int n);
|
||||
}
|
||||
|
||||
private static int sum(int[] numbers, Condition condition) {
|
||||
int result = 0;
|
||||
for (int i : numbers) {
|
||||
if (condition.isAppropriate(i)) {
|
||||
result += i;
|
||||
}
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
public static void main(String[] args) {
|
||||
System.out.println(sum(new int[] {0, 1, 0, 3, 0, 5, 0, 7, 0, 9}, (n) -> n != 0));
|
||||
}
|
||||
```
|
||||
|
||||
[к оглавлению](#java-8)
|
||||
|
||||
##К каким переменным есть доступ у лямбда-выражений?
|
||||
Доступ к переменным внешней области действия из лямбда-выражения очень схож к доступу из анонимных объектов. Можно ссылаться на:
|
||||
|
||||
+ неизменяемые (_effectively final_ - не обязательно помеченные как `final`) локальные переменные;
|
||||
+ поля класса;
|
||||
+ статические переменные.
|
||||
|
||||
К методам по умолчанию реализуемого функционального интерфейса обращаться внутри лямбда-выражения запрещено.
|
||||
|
||||
[к оглавлению](#java-8)
|
||||
|
||||
##Как отсортировать список строк с помощью лямбда-выражения?
|
||||
```java
|
||||
public static List<String> sort(List<String> list){
|
||||
Collections.sort(list, (a, b) -> a.compareTo(b));
|
||||
return list;
|
||||
}
|
||||
```
|
||||
|
||||
[к оглавлению](#java-8)
|
||||
|
||||
##Что такое «ссылка на метод»?
|
||||
Если существующий в классе метод уже делает все, что необходимо, то можно воспользоваться механизмом __method reference (ссылка на метод)__ для непосредственной передачи этого метода. Такая ссылка передается в виде:
|
||||
|
||||
+ `имя_класса::имя_статического_метода` для статического метода;
|
||||
+ `объект_класса::имя_метода` для метода экземпляра;
|
||||
+ `название_класса::new` для конструктора.
|
||||
|
||||
Результат будет в точности таким же, как в случае определения лямбда-выражения, которое вызывает этот метод.
|
||||
|
||||
```java
|
||||
private interface Measurable {
|
||||
public int length(String string);
|
||||
}
|
||||
|
||||
public static void main(String[] args) {
|
||||
Measurable a = String::length;
|
||||
System.out.println(a.length("abc"));
|
||||
}
|
||||
```
|
||||
|
||||
Ссылки на методы потенциально более эффективны, чем использование лямбда-выражений. Кроме того, они предоставляют компилятору более качественную информацию о типе и при возможности выбора между использованием ссылки на существующий метод и использованием лямбда-выражения, следует всегда предпочитать использование ссылки на метод.
|
||||
|
||||
[к оглавлению](#java-8)
|
||||
|
||||
##Какие виды ссылок на методы вы знаете?
|
||||
+ на статический метод;
|
||||
+ на метод экземпляра;
|
||||
+ на конструктор.
|
||||
|
||||
[к оглавлению](#java-8)
|
||||
|
||||
##Объясните выражение `System.out::println`.
|
||||
Заданное выражение иллюстрирует передачу ссылки на статический метод `println()` класса `System.out`.
|
||||
|
||||
[к оглавлению](#java-8)
|
||||
|
||||
##Что такое «функциональные интерфейсы»?
|
||||
__Функциональный интерфейс__ - это интерфейс, который определяет только один абстрактный метод.
|
||||
|
||||
Чтобы точно определить интерфейс как функциональный, добавлена аннотация `@FunctionalInterface`, работающая по принципу `@Override`. Она обозначит замысел и не даст определить второй абстрактный метод в интерфейсе.
|
||||
|
||||
Интерфейс может включать сколько угодно `default` методов и при этом оставаться функциональным, потому что `default` методы - не абстрактные.
|
||||
|
||||
[к оглавлению](#java-8)
|
||||
|
||||
##Для чего нужны функциональные интерфейсы `Function<T,R>`, `DoubleFunction<R>`, `IntFunction<R>` и `LongFunction<R>`?
|
||||
__`Function<T, R>`__ - интерфейс, с помощью которого реализуется функция, получающая на вход экземпляр класса `T` и возвращающая на выходе экземпляр класса `R`.
|
||||
|
||||
Методы по умолчанию могут использоваться для построения цепочек вызовов (`compose`, `andThen`).
|
||||
|
||||
```java
|
||||
Function<String, Integer> toInteger = Integer::valueOf;
|
||||
Function<String, String> backToString = toInteger.andThen(String::valueOf);
|
||||
backToString.apply("123"); // "123"
|
||||
```
|
||||
|
||||
+ `DoubleFunction<R>` - функция получающая на вход `Double` и возвращающая на выходе экземпляр класса `R`;
|
||||
+ `IntFunction<R>` - функция получающая на вход `Integer` и возвращающая на выходе экземпляр класса `R`;
|
||||
+ `LongFunction<R>` - функция получающая на вход `Long` и возвращающая на выходе экземпляр класса `R`.
|
||||
|
||||
[к оглавлению](#java-8)
|
||||
|
||||
##Для чего нужны функциональные интерфейсы `UnaryOperator<T>`, `DoubleUnaryOperator`, `IntUnaryOperator` и `LongUnaryOperator`?
|
||||
__`UnaryOperator<T>` (унарный оператор)__ принимает в качестве параметра объект типа `T`, выполняет над ними операции и возвращает результат операций в виде объекта типа `T`:
|
||||
|
||||
```java
|
||||
UnaryOperator<Integer> operator = x -> x * x;
|
||||
System.out.println(operator.apply(5)); // 25
|
||||
```
|
||||
|
||||
+ `DoubleUnaryOperator` - унарный оператор получающий на вход `Double`;
|
||||
+ `IntUnaryOperator` - унарный оператор получающий на вход `Integer`;
|
||||
+ `LongUnaryOperator` - унарный оператор получающий на вход `Long`.
|
||||
|
||||
[к оглавлению](#java-8)
|
||||
|
||||
##Для чего нужны функциональные интерфейсы `BinaryOperator<T>`, `DoubleBinaryOperator`, `IntBinaryOperator` и `LongBinaryOperator`?
|
||||
__`BinaryOperator<T>` (бинарный оператор)__ - интерфейс, с помощью которого реализуется функция, получающая на вход два экземпляра класса `T` и возвращающая на выходе экземпляр класса `T`.
|
||||
```java
|
||||
BinaryOperator<Integer> operator = (a, b) -> a + b;
|
||||
System.out.println(operator.apply(1, 2)); // 3
|
||||
```
|
||||
|
||||
+ `DoubleBinaryOperator` - бинарный оператор получающий на вход `Double`;
|
||||
+ `IntBinaryOperator` - бинарный оператор получающий на вход `Integer`;
|
||||
+ `LongBinaryOperator` - бинарный оператор получающий на вход `Long`.
|
||||
|
||||
[к оглавлению](#java-8)
|
||||
|
||||
##Для чего нужны функциональные интерфейсы `Predicate<T>`, `DoublePredicate`, `IntPredicate` и `LongPredicate`?
|
||||
__`Predicate<T>` (предикат)__ - интерфейс, с помощью которого реализуется функция, получающая на вход экземпляр класса `T` и возвращающая на выходе значение типа `boolean`.
|
||||
|
||||
Интерфейс содержит различные методы по умолчанию, позволяющие строить сложные условия (`and`, `or`, `negate`).
|
||||
|
||||
```java
|
||||
Predicate<String> predicate = (s) -> s.length() > 0;
|
||||
predicate.test("foo"); // true
|
||||
predicate.negate().test("foo"); // false
|
||||
```
|
||||
|
||||
+ `DoublePredicate` - предикат получающий на вход `Double`;
|
||||
+ `IntPredicate` - предикат получающий на вход `Integer`;
|
||||
+ `LongPredicate` - предикат получающий на вход `Long`.
|
||||
|
||||
[к оглавлению](#java-8)
|
||||
|
||||
##Для чего нужны функциональные интерфейсы `Consumer<T>`, `DoubleConsumer`, `IntConsumer` и `LongConsumer`?
|
||||
__`Consumer<T>` (потребитель)__ - интерфейс, с помощью которого реализуется функция, которая получает на вход экземпляр класса `T`, производит с ним некоторое действие и ничего не возвращает.
|
||||
|
||||
```java
|
||||
Consumer<String> hello = (name) -> System.out.println("Hello, " + name);
|
||||
hello.accept("world");
|
||||
```
|
||||
|
||||
+ `DoubleConsumer` - потребитель получающий на вход `Double`;
|
||||
+ `IntConsumer` - потребитель получающий на вход `Integer`;
|
||||
+ `LongConsumer` - потребитель получающий на вход `Long`.
|
||||
|
||||
[к оглавлению](#java-8)
|
||||
|
||||
##Для чего нужны функциональные интерфейсы `Supplier<T>`, `BooleanSupplier`, `DoubleSupplier`, `IntSupplier` и `LongSupplier`?
|
||||
__`Supplier<T>` (поставщик)__ - интерфейс, с помощью которого реализуется функция, ничего не принимающая на вход, но возвращающая на выход результат класса `T`;
|
||||
|
||||
```java
|
||||
Supplier<LocalDateTime> now = LocalDateTime::now;
|
||||
now.get();
|
||||
```
|
||||
|
||||
+ `DoubleSupplier` - поставщик возвращающий `Double`;
|
||||
+ `IntSupplier` - поставщик возвращающий `Integer`;
|
||||
+ `LongSupplier` - поставщик возвращающий `Long`.
|
||||
|
||||
[к оглавлению](#java-8)
|
||||
|
||||
##Для чего нужен функциональный интерфейс `BiConsumer<T,U>`?
|
||||
__`BiConsumer<T,U>`__ представляет собой операцию, которая принимает два аргумента классов `T` и `U` производит с ними некоторое действие и ничего не возвращает.
|
||||
|
||||
[к оглавлению](#java-8)
|
||||
|
||||
##Для чего нужен функциональный интерфейс `BiFunction<T,U,R>`?
|
||||
__`BiFunction<T,U,R>`__ представляет собой операцию, которая принимает два аргумента классов `T` и `U` и возвращающая результат класса `R`.
|
||||
|
||||
[к оглавлению](#java-8)
|
||||
|
||||
##Для чего нужен функциональный интерфейс `BiPredicate<T,U>`?
|
||||
__`BiPredicate<T,U>`__ представляет собой операцию, которая принимает два аргумента классов `T` и `U` и возвращающая результат типа `boolean`.
|
||||
|
||||
[к оглавлению](#java-8)
|
||||
|
||||
##Для чего нужны функциональные интерфейсы вида `_To_Function`?
|
||||
+ `DoubleToIntFunction` - операция принимающая аргумент класса `Double` и возвращающая результат типа `Integer`;
|
||||
+ `DoubleToLongFunction` - операция принимающая аргумент класса `Double` и возвращающая результат типа `Long`;
|
||||
+ `IntToDoubleFunction` - операция принимающая аргумент класса `Integer` и возвращающая результат типа `Double`;
|
||||
+ `IntToLongFunction` - операция принимающая аргумент класса `Integer` и возвращающая результат типа `Long`;
|
||||
+ `LongToDoubleFunction` - операция принимающая аргумент класса `Long` и возвращающая результат типа `Double`;
|
||||
+ `LongToIntFunction` - операция принимающая аргумент класса `Long` и возвращающая результат типа `Integer`.
|
||||
|
||||
[к оглавлению](#java-8)
|
||||
|
||||
##Для чего нужны функциональные интерфейсы `ToDoubleBiFunction<T,U>`, `ToIntBiFunction<T,U>` и `ToLongBiFunction<T,U>`?
|
||||
+ `ToDoubleBiFunction<T,U>` - операция принимающая два аргумента классов `T` и `U` и возвращающая результат типа `Double`;
|
||||
+ `ToLongBiFunction<T,U>` - операция принимающая два аргумента классов `T` и `U` и возвращающая результат типа `Long`;
|
||||
+ `ToIntBiFunction<T,U>` - операция принимающая два аргумента классов `T` и `U` и возвращающая результат типа `Integer`.
|
||||
|
||||
[к оглавлению](#java-8)
|
||||
|
||||
##Для чего нужны функциональные интерфейсы `ToDoubleFunction<T>`, `ToIntFunction<T>` и `ToLongFunction<T>`?
|
||||
+ `ToDoubleFunction<T>` - операция принимающая аргумент класса `T` и возвращающая результат типа `Double`;
|
||||
+ `ToLongFunction<T>` - операция принимающая аргумент класса `T` и возвращающая результат типа `Long`;
|
||||
+ `ToIntFunction<T>` - операция принимающая аргумент класса `T` и возвращающая результат типа `Integer`.
|
||||
|
||||
[к оглавлению](#java-8)
|
||||
|
||||
##Для чего нужны функциональные интерфейсы `ObjDoubleConsumer<T>`, `ObjIntConsumer<T>` и `ObjLongConsumer<T>`?
|
||||
+ `ObjDoubleConsumer<T>` - операция, которая принимает два аргумента классов `T` и `Double`, производит с ними некоторое действие и ничего не возвращает;
|
||||
+ `ObjLongConsumer<T>` - операция, которая принимает два аргумента классов `T` и `Long`, производит с ними некоторое действие и ничего не возвращает;
|
||||
+ `ObjIntConsumer<T>` - операция, которая принимает два аргумента классов `T` и `Integer`, производит с ними некоторое действие и ничего не возвращает.
|
||||
|
||||
[к оглавлению](#java-8)
|
||||
|
||||
##Что такое `StringJoiner`?
|
||||
Класс `StringJoiner` используется, чтобы создать последовательность строк, разделенных разделителем с возможностью присоединить к полученной строке префикс и суффикс:
|
||||
|
||||
```java
|
||||
StringJoiner joiner = new StringJoiner(".", "prefix-", "-suffix");
|
||||
for (String s : "Hello the brave world".split(" ")) {
|
||||
joiner.add(s);
|
||||
}
|
||||
System.out.println(joiner); //prefix-Hello.the.brave.world-suffix
|
||||
```
|
||||
|
||||
[к оглавлению](#java-8)
|
||||
|
||||
##Что такое `default` методы интрефейса?
|
||||
Java 8 позволяет добавлять неабстрактные реализации методов в интерфейс, используя ключевое слово `default`:
|
||||
|
||||
```java
|
||||
interface Example {
|
||||
int process(int a);
|
||||
default void show() {
|
||||
System.out.println("default show()");
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
+ Если класс реализует интерфейс, он может, но не обязан, реализовать методы по-умолчанию, уже реализованные в интерфейсе. Класс наследует реализацию по умолчанию.
|
||||
+ Если некий класс реализует несколько интерфейсов, которые имеют одинаковый метод по умолчанию, то класс должен реализовать метод с совпадающей сигнатурой самостоятельно. Ситуация аналогична, если один интерфейс имеет метод по умолчанию, а в другом этот же метод является абстрактным - никакой реализации по умолчанию классом не наследуется.
|
||||
+ Метод по умолчанию не может переопределить метод класса `java.lang.Object`.
|
||||
+ Помогают реализовывать интерфейсы без страха нарушить работу других классов.
|
||||
+ Позволяют избежать создания служебных классов, так как все необходимые методы могут быть представлены в самих интерфейсах.
|
||||
+ Дают свободу классам выбрать метод, который нужно переопределить.
|
||||
+ Одной из основных причин внедрения методов по умолчанию является возможность коллекций в Java 8 использовать лямбда-выражения.
|
||||
|
||||
[к оглавлению](#java-8)
|
||||
|
||||
##Как вызывать `default` метод интерфейса в реализующем этот интерфейс классе?
|
||||
Используя ключевое слово `super` вместе с именем интерфейса:
|
||||
|
||||
```java
|
||||
interface Paper {
|
||||
default void show() {
|
||||
System.out.println("default show()");
|
||||
}
|
||||
}
|
||||
|
||||
class Licence implements Paper {
|
||||
public void show() {
|
||||
Paper.super.show();
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
[к оглавлению](#java-8)
|
||||
|
||||
##Что такое `static` метод интерфейса?
|
||||
Статические методы интерфейса похожи на методы по умолчанию, за исключением того, что для них отсутствует возможность переопределения в классах, реализующих интерфейс.
|
||||
|
||||
+ Статические методы в интерфейсе являются частью интерфейса без возможности использовать их для объектов класса реализации;
|
||||
+ Методы класса `java.lang.Object` нельзя переопределить как статические;
|
||||
+ Статические методы в интерфейсе используются для обеспечения вспомогательных методов, например, проверки на null, сортировки коллекций и т.д.
|
||||
|
||||
[к оглавлению](#java-8)
|
||||
|
||||
##Как вызывать `static` метод интерфейса?
|
||||
Используя имя интерфейса:
|
||||
|
||||
```java
|
||||
interface Paper {
|
||||
static void show() {
|
||||
System.out.println("static show()");
|
||||
}
|
||||
}
|
||||
|
||||
class Licence {
|
||||
public void showPaper() {
|
||||
Paper.show();
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
[к оглавлению](#java-8)
|
||||
|
||||
##Что такое `Optional`?
|
||||
Опциональное значение `Optional` — это контейнер для объекта, который может содержать или не содержать значение `null`. Такая обёртка является удобным средством предотвращения `NullPointerException`, т.к.
|
||||
имеет некоторые функции высшего порядка, избавляющие от добавления повторяющихся `if null/notNull` проверок:
|
||||
|
||||
```java
|
||||
Optional<String> optional = Optional.of("hello");
|
||||
|
||||
optional.isPresent(); // true
|
||||
optional.ifPresent(s -> System.out.println(s.length())); // 5
|
||||
optional.get(); // "hello"
|
||||
optional.orElse("ops..."); // "hello"
|
||||
```
|
||||
|
||||
[к оглавлению](#java-8)
|
||||
|
||||
##Что такое `Stream`?
|
||||
Интерфейс `java.util.Stream` представляет собой последовательность элементов, над которой можно производить различные операции.
|
||||
|
||||
Операции над стримами бывают или _промежуточными (intermediate)_ или _конечными (terminal)_. Конечные операции возвращают результат определенного типа, а промежуточные операции возвращают тот же стрим. Таким образом вы можете строить цепочки из несколько операций над одним и тем же стримом.
|
||||
|
||||
У стрима может быть сколько угодно вызовов промежуточных операций и последним вызов конечной операции. При этом все промежуточные операции выполняются лениво и пока не будет вызвана конечная операция никаких действий на самом деле не происходит (похоже на создание объекта `Thread` или `Runnable`, без вызова `start()`).
|
||||
|
||||
Стримы создаются на основе источников каких-либо, например классов из `java.util.Collection`.
|
||||
|
||||
Ассоциативные массивы (maps), например `HashMap`, не поддерживаются.
|
||||
|
||||
Операции над стримами могут выполняться как последовательно, так и параллельно.
|
||||
|
||||
Потоки не могут быть использованы повторно. Как только была вызвана какая-нибудь конечная операция, поток закрывается.
|
||||
|
||||
Кроме универсальных объектных существуют особые виды стримов для работы с примитивными типами данных `int`, `long` и `double`: `IntStream`, `LongStream` и `DoubleStream`. Эти примитивные стримы работают так же, как и обычные объектные, но со следующими отличиями:
|
||||
|
||||
+ используют специализированные лямбда-выражения, например `IntFunction` или `IntPredicate` вместо `Function` и `Predicate`;
|
||||
+ поддерживают дополнительные конечные операции `sum()`, `average()`, `mapToObj()`.
|
||||
|
||||
[к оглавлению](#java-8)
|
||||
|
||||
##Какие существуют способы создания стрима?
|
||||
1. Из коллекции:
|
||||
```java
|
||||
Stream<String> fromCollection = Arrays.asList("x", "y", "z").stream();
|
||||
```
|
||||
2. Из набора значений:
|
||||
```java
|
||||
Stream<String> fromValues = Stream.of("x", "y", "z");
|
||||
```
|
||||
3. Из массива:
|
||||
```java
|
||||
Stream<String> fromArray = Arrays.stream(new String[]{"x", "y", "z"});
|
||||
```
|
||||
4. Из файла (каждая строка в файле будет отдельным элементом в стриме):
|
||||
```java
|
||||
Stream<String> fromFile = Files.lines(Paths.get("input.txt"));
|
||||
```
|
||||
5. Из строки:
|
||||
```java
|
||||
IntStream fromString = "0123456789".chars();
|
||||
```
|
||||
6. С помощью `Stream.builder()`:
|
||||
```java
|
||||
Stream<String> fromBuilder = Stream.builder().add("z").add("y").add("z").build();
|
||||
```
|
||||
7. С помощью `Stream.iterate()` (бесконечный):
|
||||
```java
|
||||
Stream<Integer> fromIterate = Stream.iterate(1, n -> n + 1);
|
||||
```
|
||||
8. С помощью `Stream.generate()` (бесконечный):
|
||||
```java
|
||||
Stream<String> fromGenerate = Stream.generate(() -> "0");
|
||||
```
|
||||
|
||||
[к оглавлению](#java-8)
|
||||
|
||||
##В чем разница между `Collection` и `Stream`?
|
||||
Коллекции позволяют работать с элементами по-отдельности, тогда как стримы так делать не позволяет, но вместо этого предоставляет возможность выполнять функции над данными как над одним целым.
|
||||
|
||||
[к оглавлению](#java-8)
|
||||
|
||||
##Для чего нужен метод `collect()` в стримах?
|
||||
Метод `collect()` является конечной операцией, которая используется для представление результата в виде коллекции или какой-либо другой структуры данных.
|
||||
|
||||
`collect()` принимает на вход `Collector<Тип_источника, Тип_аккумулятора, Тип_результата>`, который содержит четыре этапа: _supplier_ - инициализация аккумулятора, _accumulator_ - обработка каждого элемента, _combiner_ - соединение двух аккумуляторов при параллельном выполнении, _[finisher]_ - необязательный метод последней обработки аккумулятора. В Java 8 в классе `Collectors` реализовано несколько распространённых коллекторов:
|
||||
|
||||
+ `toList()`, `toCollection()`, `toSet()` - представляют стрим в виде списка, коллекции или множества;
|
||||
+ `toConcurrentMap()`, `toMap()` - позволяют преобразовать стрим в `Map`;
|
||||
+ `averagingInt()`, `averagingDouble()`, `averagingLong()` - возвращают среднее значение;
|
||||
+ `summingInt()`, `summingDouble()`, `summingLong()` - возвращает сумму;
|
||||
+ `summarizingInt()`, `summarizingDouble()`, `summarizingLong()` - возвращают `SummaryStatistics` с разными агрегатными значениями;
|
||||
+ `partitioningBy()` - разделяет коллекцию на две части по соответствию условию и возвращает их как `Map<Boolean, List>`;
|
||||
+ `groupingBy()` - разделяет коллекцию на несколько частей и возвращает `Map<N, List<T>>`;
|
||||
+ `mapping()` - дополнительные преобразования значений для сложных `Collector`-ов.
|
||||
|
||||
Так же существует возможность создания собственного коллектора через `Collector.of()`:
|
||||
|
||||
```java
|
||||
Collector<String, List<String>, List<String>> toList = Collector.of(
|
||||
ArrayList::new,
|
||||
List::add,
|
||||
(l1, l2) -> { l1.addAll(l2); return l1; }
|
||||
);
|
||||
```
|
||||
|
||||
[к оглавлению](#java-8)
|
||||
|
||||
##Для чего в стримах применяются методы `forEach()` и `forEachOrdered()`?
|
||||
+ `forEach()` применяет функцию к каждому объекту стрима, порядок при параллельном выполнении не гарантируется;
|
||||
+ `forEachOrdered()` применяет функцию к каждому объекту стрима с сохранением порядка элементов.
|
||||
|
||||
[к оглавлению](#java-8)
|
||||
|
||||
##Для чего в стримах предназначены методы `map()` и `mapToInt()`, `mapToDouble()`, `mapToLong()`?
|
||||
Метод `map()` является промежуточной операцией, которая заданным образом преобразует каждый элемент стрима.
|
||||
|
||||
`mapToInt()`, `mapToDouble()`, `mapToLong()` - аналоги `map()`, возвращающие соответствующий числовой стрим (то есть стрим из числовых примитивов):
|
||||
|
||||
```java
|
||||
Stream
|
||||
.of("12", "22", "4", "444", "123")
|
||||
.mapToInt(Integer::parseInt)
|
||||
.toArray(); //[12, 22, 4, 444, 123]
|
||||
```
|
||||
[к оглавлению](#java-8)
|
||||
|
||||
##Какова цель метода `filter()` в стримах?
|
||||
Метод `filter()` является промежуточной операцией принимающей предикат, который фильтрует все элементы, возвращая только те, что соответствуют условию.
|
||||
|
||||
[к оглавлению](#java-8)
|
||||
|
||||
##Для чего в стримах предназначен метод `limit()`?
|
||||
Метод `limit()` является промежуточной операцией, которая позволяет ограничить выборку определенным количеством первых элементов.
|
||||
|
||||
[к оглавлению](#java-8)
|
||||
|
||||
##Для чего в стримах предназначен метод `sorted()`?
|
||||
Метод `sorted()` является промежуточной операцией, которая позволяет сортировать значения либо в натуральном порядке, либо задавая `Comparator`.
|
||||
|
||||
Порядок элементов в исходной коллекции остается нетронутым - `sorted()` всего лишь создает его отсортированное представление.
|
||||
|
||||
[к оглавлению](#java-8)
|
||||
|
||||
##Для чего в стримах предназначены методы `flatMap()`, `flatMapToInt()`, `flatMapToDouble()`, `flatMapToLong()`?
|
||||
Метод `flatMap()` похож на map, но может создавать из одного элемента несколько. Таким образом, каждый объект будет преобразован в ноль, один или несколько других объектов, поддерживаемых потоком. Наиболее очевидный способ применения этой операции — преобразование элементов контейнера при помощи функций, которые возвращают контейнеры.
|
||||
|
||||
```java
|
||||
Stream
|
||||
.of("H e l l o", "w o r l d !")
|
||||
.flatMap((p) -> Arrays.stream(p.split(",")))
|
||||
.toArray(String[]::new);//["H", "e", "l", "l", "o", "w", "o", "r", "l", "d", "!"]
|
||||
```
|
||||
|
||||
`flatMapToInt()`, `flatMapToDouble()`, `flatMapToLong()` - это аналоги `flatMap()`, возвращающие соответствующий числовой стрим.
|
||||
|
||||
[к оглавлению](#java-8)
|
||||
|
||||
##Расскажите о параллельной обработке в Java 8.
|
||||
Стримы могут быть последовательными и параллельными. Операции над последовательными стримами выполняются в одном потоке процессора, над параллельными — используя несколько потоков процессора. Параллельные стримы используют общий `ForkJoinPool` доступный через статический `ForkJoinPool.commonPool()` метод. При этом, если окружение не является многоядерным, то поток будет выполняться как последовательный. Фактически применение параллельных стримов сводится к тому, что данные в стримах будут разделены на части, каждая часть обрабатывается на отдельном ядре процессора, и в конце эти части соединяются, и над ними выполняются конечные операции.
|
||||
|
||||
Для создания параллельного потока из коллекции можно также использовать метод `parallelStream()` интерфейса `Collection`.
|
||||
|
||||
Чтобы сделать обычный последовательный стрим параллельным, надо вызвать у объекта `Stream` метод `parallel()`. Метод `isParallel()` позволяет узнать является ли стрим параллельным.
|
||||
|
||||
С помощью, методов `parallel()` и `sequential()` можно определять какие операции могут быть параллельными, а какие только последовательными. Так же из любого последовательного стрима можно сделать параллельный и наоборот:
|
||||
|
||||
```java
|
||||
collection
|
||||
.stream()
|
||||
.peek(...) // операция последовательна
|
||||
.parallel()
|
||||
.map(...) // операция может выполняться параллельно,
|
||||
.sequential()
|
||||
.reduce(...) // операция снова последовательна
|
||||
```
|
||||
|
||||
Как правило, элементы передаются в стрим в том же порядке, в котором они определены в источнике данных. При работе с параллельными стримами система сохраняет порядок следования элементов. Исключение составляет метод `forEach()`, который может выводить элементы в произвольном порядке. И чтобы сохранить порядок следования, необходимо применять метод `forEachOrdered()`.
|
||||
|
||||
Критерии, которые могут повлиять на производительность в параллельных стримах:
|
||||
|
||||
+ Размер данных - чем больше данных, тем сложнее сначала разделять данные, а потом их соединять.
|
||||
+ Количество ядер процессора. Теоретически, чем больше ядер в компьютере, тем быстрее программа будет работать. Если на машине одно ядро, нет смысла применять параллельные потоки.
|
||||
+ Чем проще структура данных, с которой работает поток, тем быстрее будут происходить операции. Например, данные из `ArrayList` легко использовать, так как структура данной коллекции предполагает последовательность несвязанных данных. А вот коллекция типа `LinkedList` - не лучший вариант, так как в последовательном списке все элементы связаны с предыдущими/последующими. И такие данные трудно распараллелить.
|
||||
+ Над данными примитивных типов операции будут производиться быстрее, чем над объектами классов.
|
||||
+ Крайне не рекомендуется использовать параллельные стримы для сколько-нибудь долгих операций (например сетевых соединений), так как все параллельные стримы работают c одним `ForkJoinPool`, то такие долгие операции могут остановить работу всех параллельных стримов в JVM из-за отсутствия доступных потоков в пуле, т.е. параллельные стримы стоит использовать лишь для коротких операций, где счет идет на миллисекунды, но не для тех где счет может идти на секунды и минуты;
|
||||
+ Сохранение порядка в параллельных стримах увеличивает издержки при выполнении и если порядок не важен, то имеется возможность отключить его сохранение и тем самым увеличить производительность, использовав промежуточную операцию `unordered()`:
|
||||
|
||||
```java
|
||||
collection.parallelStream()
|
||||
.sorted()
|
||||
.unordered()
|
||||
.collect(Collectors.toList());
|
||||
```
|
||||
|
||||
[к оглавлению](#java-8)
|
||||
|
||||
##Какие конечные методы работы со стримами вы знаете?
|
||||
+ `findFirst()` возвращает первый элемент;
|
||||
+ `findAny()` возвращает любой подходящий элемент;
|
||||
+ `collect()` представление результатов в виде коллекций и других структур данных;
|
||||
+ `count()` возвращает количество элементов;
|
||||
+ `anyMatch()` возвращает `true`, если условие выполняется хотя бы для одного элемента;
|
||||
+ `noneMatch()` возвращает `true`, если условие не выполняется ни для одного элемента;
|
||||
+ `allMatch()` возвращает `true`, если условие выполняется для всех элементов;
|
||||
+ `min()` возвращает минимальный элемент, используя в качестве условия `Comparator`;
|
||||
+ `max()` возвращает максимальный элемент, используя в качестве условия `Comparator`;
|
||||
+ `forEach()` применяет функцию к каждому объекту (порядок при параллельном выполнении не гарантируется);
|
||||
+ `forEachOrdered()` применяет функцию к каждому объекту с сохранением порядка элементов;
|
||||
+ `toArray()` возвращает массив значений;
|
||||
+ `reduce()`позволяет выполнять агрегатные функции и возвращать один результат.
|
||||
|
||||
Для числовых стримов дополнительно доступны:
|
||||
|
||||
+ `sum()` возвращает сумму всех чисел;
|
||||
+ `average()` возвращает среднее арифметическое всех чисел.
|
||||
|
||||
[к оглавлению](#java-8)
|
||||
|
||||
##Какие промежуточные методы работы со стримами вы знаете?
|
||||
+ `filter()` отфильтровывает записи, возвращая только записи, соответствующие условию;
|
||||
+ `skip()` позволяет пропустить определённое количество элементов в начале;
|
||||
+ `distinct()` возвращает стрим без дубликатов (для метода `equals()`);
|
||||
+ `map()` преобразует каждый элемент;
|
||||
+ `peek()` возвращает тот же стрим, применяя к каждому элементу функцию;
|
||||
+ `limit()` позволяет ограничить выборку определенным количеством первых элементов;
|
||||
+ `sorted()` позволяет сортировать значения либо в натуральном порядке, либо задавая `Comparator`;
|
||||
+ `mapToInt()`, `mapToDouble()`, `mapToLong()` - аналоги `map()` возвращающие стрим числовых примитивов;
|
||||
+ `flatMap()`, `flatMapToInt()`, `flatMapToDouble()`, `flatMapToLong()` - похожи на `map()`, но могут создавать из одного элемента несколько.
|
||||
|
||||
Для числовых стримов дополнительно доступен метод `mapToObj()`, который преобразует числовой стрим обратно в объектный.
|
||||
|
||||
[к оглавлению](#java-8)
|
||||
|
||||
##Как вывести на экран 10 случайных чисел, используя `forEach()`?
|
||||
```java
|
||||
(new Random())
|
||||
.ints()
|
||||
.limit(10)
|
||||
.forEach(System.out::println);
|
||||
```
|
||||
|
||||
[к оглавлению](#java-8)
|
||||
|
||||
##Как можно вывести на экран уникальные квадраты чисел используя метод `map()`?
|
||||
```java
|
||||
Stream
|
||||
.of(1, 2, 3, 2, 1)
|
||||
.map(s -> s * s)
|
||||
.distinct()
|
||||
.collect(Collectors.toList())
|
||||
.forEach(System.out::println);
|
||||
```
|
||||
|
||||
[к оглавлению](#java-8)
|
||||
|
||||
##Как вывести на экран количество пустых строк с помощью метода `filter()`?
|
||||
```java
|
||||
System.out.println(
|
||||
Stream
|
||||
.of("Hello", "", ", ", "world", "!")
|
||||
.filter(String::isEmpty)
|
||||
.count());
|
||||
```
|
||||
|
||||
[к оглавлению](#java-8)
|
||||
|
||||
##Как вывести на экран 10 случайных чисел в порядке возрастания?
|
||||
```java
|
||||
(new Random())
|
||||
.ints()
|
||||
.limit(10)
|
||||
.sorted()
|
||||
.forEach(System.out::println);
|
||||
```
|
||||
|
||||
[к оглавлению](#java-8)
|
||||
|
||||
##Как найти максимальное число в наборе?
|
||||
```java
|
||||
Stream
|
||||
.of(5, 3, 4, 55, 2)
|
||||
.mapToInt(a -> a)
|
||||
.max()
|
||||
.getAsInt(); //55
|
||||
```
|
||||
|
||||
[к оглавлению](#java-8)
|
||||
|
||||
##Как найти минимальное число в наборе?
|
||||
```java
|
||||
Stream
|
||||
.of(5, 3, 4, 55, 2)
|
||||
.mapToInt(a -> a)
|
||||
.min()
|
||||
.getAsInt(); //2
|
||||
```
|
||||
[к оглавлению](#java-8)
|
||||
|
||||
##Как получить сумму всех чисел в наборе?
|
||||
```java
|
||||
Stream
|
||||
.of(5, 3, 4, 55, 2)
|
||||
.mapToInt()
|
||||
.sum(); //69
|
||||
```
|
||||
[к оглавлению](#java-8)
|
||||
|
||||
##Как получить среднее значение всех чисел?
|
||||
```java
|
||||
Stream
|
||||
.of(5, 3, 4, 55, 2)
|
||||
.mapToInt(a -> a)
|
||||
.average()
|
||||
.getAsDouble(); //13.8
|
||||
```
|
||||
[к оглавлению](#java-8)
|
||||
|
||||
##Какие дополнительные методы для работы с ассоциативными массивами (maps) появились в Java 8?
|
||||
+ `putIfAbsent()` добавляет пару «ключ-значение», только если ключ отсутствовал:
|
||||
|
||||
`map.putIfAbsent("a", "Aa");`
|
||||
|
||||
+ `forEach()` принимает функцию, которая производит операцию над каждым элементом:
|
||||
|
||||
`map.forEach((k, v) -> System.out.println(v));`
|
||||
|
||||
+ `compute()` создаёт или обновляет текущее значение на полученное в результате вычисления (возможно использовать ключ и текущее значение):
|
||||
|
||||
`map.compute("a", (k, v) -> String.valueOf(k).concat(v)); //["a", "aAa"]`
|
||||
|
||||
+ `computeIfPresent()` если ключ существует, обновляет текущее значение на полученное в результате вычисления (возможно использовать ключ и текущее значение):
|
||||
|
||||
`map.computeIfPresent("a", (k, v) -> k.concat(v));`
|
||||
|
||||
+ `computeIfAbsent()` если ключ отсутствует, создаёт его со значением, которое вычисляется (возможно использовать ключ):
|
||||
|
||||
`map.computeIfAbsent("a", k -> "A".concat(k)); //["a","Aa"]`
|
||||
|
||||
+ `getOrDefault()` в случае отсутствия ключа, возвращает переданное значение по-умолчанию:
|
||||
|
||||
`map.getOrDefault("a", "not found");`
|
||||
|
||||
+ `merge()` принимает ключ, значение и функцию, которая объединяет передаваемое и текущее значения. Если под заданным ключем значение отсутствует, то записывает туда передаваемое значение.
|
||||
|
||||
`map.merge("a", "z", (value, newValue) -> value.concat(newValue)); //["a","Aaz"]`
|
||||
|
||||
[к оглавлению](#java-8)
|
||||
|
||||
##Что такое `LocalDateTime`?
|
||||
`LocalDateTime` объединяет вместе `LocaleDate` и `LocalTime`, содержит дату и время в календарной системе ISO-8601 без привязки к часовому поясу. Время хранится с точностью до наносекунды. Содержит множество удобных методов, таких как plusMinutes, plusHours, isAfter, toSecondOfDay и т.д.
|
||||
|
||||
[к оглавлению](#java-8)
|
||||
|
||||
##Что такое `ZonedDateTime`?
|
||||
`java.time.ZonedDateTime` — аналог `java.util.Calendar`, класс с самым полным объемом информации о временном контексте в календарной системе ISO-8601. Включает временную зону, поэтому все операции с временными сдвигами этот класс проводит с её учётом.
|
||||
|
||||
[к оглавлению](#java-8)
|
||||
|
||||
##Как получить текущую дату с использованием Date Time API из Java 8?
|
||||
```java
|
||||
LocalDate.now();
|
||||
```
|
||||
|
||||
[к оглавлению](#java-8)
|
||||
|
||||
##Как добавить 1 неделю, 1 месяц, 1 год, 10 лет к текущей дате с использованием Date Time API?
|
||||
```java
|
||||
LocalDate.now().plusWeeks(1);
|
||||
LocalDate.now().plusMonths(1);
|
||||
LocalDate.now().plusYears(1);
|
||||
LocalDate.now().plus(1, ChronoUnit.DECADES);
|
||||
```
|
||||
|
||||
[к оглавлению](#java-8)
|
||||
|
||||
##Как получить следующий вторник используя Date Time API?
|
||||
```java
|
||||
LocalDate.now().with(TemporalAdjusters.next(DayOfWeek.TUESDAY));
|
||||
```
|
||||
|
||||
[к оглавлению](#java-8)
|
||||
|
||||
##Как получить вторую субботу текущего месяца используя Date Time API?
|
||||
```java
|
||||
LocalDate
|
||||
.of(LocalDate.now().getYear(), LocalDate.now().getMonth(), 1)
|
||||
.with(TemporalAdjusters.nextOrSame(DayOfWeek.SATURDAY))
|
||||
.with(TemporalAdjusters.next(DayOfWeek.SATURDAY));
|
||||
```
|
||||
|
||||
[к оглавлению](#java-8)
|
||||
|
||||
##Как получить текущее время с точностью до миллисекунд используя Date Time API?
|
||||
```java
|
||||
new Date().toInstant();
|
||||
```
|
||||
|
||||
[к оглавлению](#java-8)
|
||||
|
||||
##Как получить текущее время по местному времени с точностью до миллисекунд используя Date Time API?
|
||||
```java
|
||||
LocalDateTime.ofInstant(new Date().toInstant(), ZoneId.systemDefault());
|
||||
```
|
||||
|
||||
[к оглавлению](#java-8)
|
||||
|
||||
##Как определить повторяемую аннотацию?
|
||||
Чтобы определить повторяемую аннотацию, необходимо создать аннотацию-контейнер для списка повторяемых аннотаций и обозначить повторяемую мета-аннотацией `@Repeatable`:
|
||||
|
||||
```java
|
||||
@interface Schedulers
|
||||
{
|
||||
Scheduler[] value();
|
||||
}
|
||||
|
||||
@Repeatable(Schedulers.class)
|
||||
@interface Scheduler
|
||||
{
|
||||
String birthday() default "Jan 8 1935";
|
||||
}
|
||||
```
|
||||
|
||||
[к оглавлению](#java-8)
|
||||
|
||||
##Что такое `Nashorn`?
|
||||
__Nashorn__ - это движок JavaScript, разрабатываемый на Java компанией Oracle. Призван дать возможность встраивать код JavaScript в приложения Java. В сравнении с _Rhino_, который поддерживается Mozilla Foundation, Nashorn обеспечивает от 2 до 10 раз более высокую производительность, так как он компилирует код и передает байт-код виртуальной машине Java непосредственно в памяти. Nashorn умеет компилировать код JavaScript и генерировать классы Java, которые загружаются специальным загрузчиком. Так же возможен вызов кода Java прямо из JavaScript.
|
||||
|
||||
[к оглавлению](#java-8)
|
||||
|
||||
##Что такое `jjs`?
|
||||
`jjs` это утилита командной строки, которая позволяет исполнять программы на языке JavaScript прямо в консоли.
|
||||
|
||||
[к оглавлению](#java-8)
|
||||
|
||||
##Какой класс появился в Java 8 для кодирования/декодирования данных?
|
||||
`Base64` - потокобезопасный класс, который реализует кодировщик и декодировщик данных, используя схему кодирования base64 согласно _RFC 4648_ и _RFC 2045_.
|
||||
|
||||
Base64 содержит 6 основных методов:
|
||||
|
||||
`getEncoder()`/`getDecoder()` - возвращает кодировщик/декодировщик base64, соответствующий стандарту _RFC 4648_;
|
||||
`getUrlEncoder()`/`getUrlDecoder()` - возвращает URL-safe кодировщик/декодировщик base64, соответствующий стандарту _RFC 4648_;
|
||||
`getMimeEncoder()`/`getMimeDecoder()` - возвращает MIME кодировщик/декодировщик, соответствующий стандарту _RFC 2045_.
|
||||
|
||||
[к оглавлению](#java-8)
|
||||
|
||||
##Как создать Base64 кодировщик и декодировщик?
|
||||
```java
|
||||
// Encode
|
||||
String b64 = Base64.getEncoder().encodeToString("input".getBytes("utf-8")); //aW5wdXQ==
|
||||
// Decode
|
||||
new String(Base64.getDecoder().decode("aW5wdXQ=="), "utf-8"); //input
|
||||
```
|
||||
|
||||
[к оглавлению](#java-8)
|
||||
|
||||
#Источники
|
||||
+ [Хабрахабр - Новое в Java 8](https://habrahabr.ru/post/216431/)
|
||||
+ [Хабрахабр - Шпаргалка Java программиста 4. Java Stream API](https://habrahabr.ru/company/luxoft/blog/270383/)
|
||||
+ [METANIT.COM](http://metanit.com/java/tutorial/9.1.php)
|
||||
+ [javadevblog.com](http://javadevblog.com/interfejsy-v-java-8-staticheskie-metody-metody-po-umolchaniyu-funktsional-ny-e-interfejsy.html)
|
||||
|
|
@ -0,0 +1,784 @@
|
|||
[Вопросы для собеседования на Java Junior](README.md)
|
||||
|
||||
#Java Collections Framework
|
||||
+ [Что такое _«коллекция»_?](#Что-такое-коллекция)
|
||||
+ [Назовите основные интерфейсы JCF и их реализации.](#Назовите-основные-интерфейсы-jcf-и-их-реализации)
|
||||
+ [Расположите в виде иерархии следующие интерфейсы: `List`, `Set`, `Map`, `SortedSet`, `SortedMap`, `Collection`, `Iterable`, `Iterator`, `NavigableSet`, `NavigableMap`.](#Расположите-в-виде-иерархии-следующие-интерфейсы-list-set-map-sortedset-sortedmap-collection-iterable-iterator-navigableset-navigablemap)
|
||||
+ [Почему `Map` — это не `Collection`, в то время как `List` и `Set` являются `Collection`?](#Почему-map--это-не-collection-в-то-время-как-list-и-set-являются-collection)
|
||||
+ [В чем разница между классами `java.util.Collection` и `java.util.Collections`?](#В-чем-разница-между-классами-javautilcollection-и-javautilcollections)
|
||||
+ [Что такое «fail-fast поведение»?](#Что-такое-fail-fast-поведение)
|
||||
+ [Какая разница между fail-fast и fail-safe?](#Какая-разница-между-fail-fast-и-fail-safe)
|
||||
+ [Приведите примеры итераторов реализующих поведение fail-safe](#Приведите-примеры-итераторов-реализующих-поведение-fail-safe)
|
||||
+ [Чем различаются `Enumeration` и `Iterator`.](#Чем-различаются-enumeration-и-iterator)
|
||||
+ [Как между собой связаны `Iterable` и `Iterator`?](#Как-между-собой-связаны-iterable-и-iterator)
|
||||
+ [Как между собой связаны `Iterable`, `Iterator` и «for-each»?](#Как-между-собой-связаны-iterable-iterator-и-for-each)
|
||||
+ [Сравните `Iterator` и `ListIterator`.](#Сравните-iterator-и-listiterator)
|
||||
+ [Что произойдет при вызове `Iterator.next()` без предварительного вызова `Iterator.hasNext()`?](#Что-произойдет-при-вызове-iteratornext-без-предварительного-вызова-iteratorhasnext)
|
||||
+ [Сколько элементов будет пропущено, если `Iterator.next()` будет вызван после 10-ти вызовов `Iterator.hasNext()`?](#Сколько-элементов-будет-пропущено-если-iteratornext-будет-вызван-после-10-ти-вызовов-iteratorhasnext)
|
||||
+ [Как поведёт себя коллекция, если вызвать `iterator.remove()`?](#Как-поведёт-себя-коллекция-если-вызвать-iteratorremove)
|
||||
+ [Как поведёт себя уже инстанциированный итератор для `collection`, если вызвать `collection.remove()`?](#Как-поведёт-себя-уже-инстанциированный-итератор-для-collection-если-вызвать-collectionremove)
|
||||
+ [Как избежать `ConcurrentModificationException` во время перебора коллекции?](#Как-избежать-concurrentmodificationexception-во-время-перебора-коллекции)
|
||||
+ [Какая коллекция реализует дисциплину обслуживания FIFO?](#Какая-коллекция-реализует-дисциплину-обслуживания-fifo)
|
||||
+ [Какая коллекция реализует дисциплину обслуживания FILO?](#Какая-коллекция-реализует-дисциплину-обслуживания-filo)
|
||||
+ [Чем отличается `ArrayList` от `Vector`?](#Чем-отличается-arraylist-от-vector)
|
||||
+ [Зачем добавили `ArrayList`, если уже был `Vector`?](#Зачем-добавили-arraylist-если-уже-был-vector)
|
||||
+ [Чем отличается `ArrayList` от `LinkedList`? В каких случаях лучше использовать первый, а в каких второй?](#Чем-отличается-arraylist-от-linkedlist-В-каких-случаях-лучше-использовать-первый-а-в-каких-второй)
|
||||
+ [Что работает быстрее `ArrayList` или `LinkedList`?](#Что-работает-быстрее-arraylist-или-linkedlist)
|
||||
+ [Какое худшее время работы метода `contains()` для элемента, который есть в `LinkedList`?](#Какое-худшее-время-работы-метода-contains-для-элемента-который-есть-в-linkedlist)
|
||||
+ [Какое худшее время работы метода `contains()` для элемента, который есть в `ArrayList`?](#Какое-худшее-время-работы-метода-contains-для-элемента-который-есть-в-arraylist)
|
||||
+ [Какое худшее время работы метода `add()` для `LinkedList`?](#Какое-худшее-время-работы-метода-add-для-linkedlist)
|
||||
+ [Какое худшее время работы метода `add()` для `ArrayList`?](#Какое-худшее-время-работы-метода-add-для-arraylist)
|
||||
+ [Необходимо добавить 1 млн. элементов, какую структуру вы используете?](#Необходимо-добавить-1-млн-элементов-какую-структуру-вы-используете)
|
||||
+ [Как происходит удаление элементов из `ArrayList`? Как меняется в этом случае размер `ArrayList`?](#Как-происходит-удаление-элементов-из-arraylist-Как-меняется-в-этом-случае-размер-arraylist)
|
||||
+ [Предложите эффективный алгоритм удаления нескольких рядом стоящих элементов из середины списка, реализуемого `ArrayList`.](#Предложите-эффективный-алгоритм-удаления-нескольких-рядом-стоящих-элементов-из-середины-списка-реализуемого-arraylist)
|
||||
+ [Сколько необходимо дополнительной памяти при вызове `ArrayList.add()`?](#Сколько-необходимо-дополнительной-памяти-при-вызове-arraylistadd)
|
||||
+ [Сколько выделяется дополнительно памяти при вызове `LinkedList.add()`?](#Сколько-выделяется-дополнительно-памяти-при-вызове-linkedlistadd)
|
||||
+ [Оцените количество памяти на хранение одного примитива типа `byte` в `LinkedList`?](#Оцените-количество-памяти-на-хранение-одного-примитива-типа-byte-в-linkedlist)
|
||||
+ [Оцените количество памяти на хранение одного примитива типа `byte` в `ArrayList`?](#Оцените-количество-памяти-на-хранение-одного-примитива-типа-byte-в-arraylist)
|
||||
+ [Для `ArrayList` или для `LinkedList` операция добавления элемента в середину (`list.add(list.size()/2, newElement)`) медленнее?](#Для-arraylist-или-для-linkedlist-операция-добавления-элемента-в-середину-listaddlistsize2-newelement-медленнее)
|
||||
+ [В реализации класса `ArrayList` есть следующие поля: `Object[] elementData`, `int size`. Объясните, зачем хранить отдельно `size`, если всегда можно взять `elementData.length`?](#В-реализации-класса-arraylist-есть-следующие-поля-object-elementdata-int-size-Объясните-зачем-хранить-отдельно-size-если-всегда-можно-взять-elementdatalength)
|
||||
+ [Сравните интерфейсы `Queue` и `Deque`.](#Сравните-интерфейсы-queue-и-deque)
|
||||
+ [Кто кого расширяет: `Queue` расширяет `Deque`, или `Deque` расширяет `Queue`?](#Кто-кого-расширяет-queue-расширяет-deque-или-deque-расширяет-queue)
|
||||
+ [Почему `LinkedList` реализует и `List`, и `Deque`?](#Почему-linkedlist-реализует-и-list-и-deque)
|
||||
+ [`LinkedList` — это односвязный, двусвязный или четырехсвязный список?](#linkedlist--это-односвязный-двусвязный-или-четырехсвязный-список)
|
||||
+ [Как перебрать элементы `LinkedList` в обратном порядке, не используя медленный `get(index)`?](#Как-перебрать-элементы-linkedlist-в-обратном-порядке-не-используя-медленный-getindex)
|
||||
+ [Что позволяет сделать `PriorityQueue`?](#Что-позволяет-сделать-priorityqueue)
|
||||
+ [`Stack` считается «устаревшим». Чем его рекомендуют заменять? Почему?](#stack-считается-устаревшим-Чем-его-рекомендуют-заменять-Почему)
|
||||
+ [Зачем нужен `HashMap`, если есть `Hashtable`?](#Зачем-нужен-hashmap-если-есть-hashtable)
|
||||
+ [В чем разница между `HashMap` и `IdentityHashMap`? Для чего нужна `IdentityHashMap`?](#В-чем-разница-между-hashmap-и-identityhashmap-Для-чего-нужна-identityhashmap)
|
||||
+ [В чем разница между `HashMap` и `WeakHashMap`? Для чего используется `WeakHashMap`?](#В-чем-разница-между-hashmap-и-weakhashmap-Для-чего-используется-weakhashmap)
|
||||
+ [В `WeakHashMap` используются WeakReferences. А почему бы не создать `SoftHashMap` на SoftReferences?](#В-weakhashmap-используются-weakreferences-А-почему-бы-не-создать-softhashmap-на-softreferences)
|
||||
+ [В `WeakHashMap` используются WeakReferences. А почему бы не создать `PhantomHashMap` на PhantomReferences?](#В-weakhashmap-используются-weakreferences-А-почему-бы-не-создать-phantomhashmap-на-phantomreferences)
|
||||
+ [`LinkedHashMap` - что в нем от `LinkedList`, а что от `HashMap`?](#linkedhashmap---что-в-нем-от-linkedlist-а-что-от-hashmap)
|
||||
+ [В чем проявляется «сортированность» `SortedMap`, кроме того, что `toString()` выводит все элементы по порядку?](#В-чем-проявляется-сортированность-sortedmap-кроме-того-что-tostring-выводит-все-элементы-по-порядку)
|
||||
+ [Как устроен `HashMap`?](#Как-устроен-hashmap)
|
||||
+ [Согласно Кнуту и Кормену существует две основных реализации хэш-таблицы: на основе открытой адресации и на основе метода цепочек. Как реализована `HashMap`? Почему, по вашему мнению, была выбрана именно эта реализация? В чем плюсы и минусы каждого подхода?](#Согласно-Кнуту-и-Кормену-существует-две-основных-реализации-хэш-таблицы-на-основе-открытой-адресации-и-на-основе-метода-цепочек-Как-реализована-hashmap-Почему-по-вашему-мнению-была-выбрана-именно-эта-реализация-В-чем-плюсы-и-минусы-каждого-подхода)
|
||||
+ [Как работает `HashMap` при попытке сохранить в него два элемента по ключам с одинаковым `hashCode()`, но для которых `equals() == false`?](#Как-работает-hashmap-при-попытке-сохранить-в-него-два-элемента-по-ключам-с-одинаковым-hashcode-но-для-которых-equals--false)
|
||||
+ [Какое начальное количество корзин в `HashMap`?](#Какое-начальное-количество-корзин-в-hashmap)
|
||||
+ [Какова оценка временной сложности операций над элементами из `HashMap`? Гарантирует ли `HashMap` указанную сложность выборки элемента?](#Какова-оценка-временной-сложности-операций-над-элементами-из-hashmap-Гарантирует-ли-hashmap-указанную-сложность-выборки-элемента)
|
||||
+ [Возможна ли ситуация, когда `HashMap` выродится в список даже с ключами имеющими разные `hashCode()`?](#Возможна-ли-ситуация-когда-hashmap-выродится-в-список-даже-с-ключами-имеющими-разные-hashcode)
|
||||
+ [В каком случае может быть потерян элемент в `HashMap`?](#В-каком-случае-может-быть-потерян-элемент-в-hashmap)
|
||||
+ [Почему нельзя использовать `byte[]` в качестве ключа в `HashMap`?](#Почему-нельзя-использовать-byte-в-качестве-ключа-в-hashmap)
|
||||
+ [Какова роль `equals()` и `hashCode()` в `HashMap`?](#Какова-роль-equals-и-hashcode-в-hashmap)
|
||||
+ [Каково максимальное число значений `hashCode()`?](#Каково-максимальное-число-значений-hashcode)
|
||||
+ [Какое худшее время работы метода get(key) для ключа, которого нет в `HashMap`?](#Какое-худшее-время-работы-метода-getkey-для-ключа-которого-нет-в-hashmap)
|
||||
+ [Какое худшее время работы метода get(key) для ключа, который есть в `HashMap`?](#Какое-худшее-время-работы-метода-getkey-для-ключа-который-есть-в-hashmap)
|
||||
+ [Сколько переходов происходит в момент вызова `HashMap.get(key)` по ключу, который есть в таблице?](#Сколько-переходов-происходит-в-момент-вызова-hashmapgetkey-по-ключу-который-есть-в-таблице)
|
||||
+ [Сколько создается новых объектов, когда вы добавляете новый элемент в `HashMap`?](#Сколько-создается-новых-объектов-когда-вы-добавляете-новый-элемент-в-hashmap)
|
||||
+ [Как и когда происходит увеличение количества корзин в `HashMap`?](#Как-и-когда-происходит-увеличение-количества-корзин-в-hashmap)
|
||||
+ [Объясните смысл параметров в конструкторе `HashMap(int initialCapacity, float loadFactor)`.](#Объясните-смысл-параметров-в-конструкторе-hashmapint-initialcapacity-float-loadfactor)
|
||||
+ [Будет ли работать `HashMap`, если все добавляемые ключи будут иметь одинаковый `hashCode()`?](#Будет-ли-работать-hashmap-если-все-добавляемые-ключи-будут-иметь-одинаковый-hashcode)
|
||||
+ [Как перебрать все ключи `Map`?](#Как-перебрать-все-ключи-map)
|
||||
+ [Как перебрать все значения `Map`?](#Как-перебрать-все-значения-map)
|
||||
+ [Как перебрать все пары «ключ-значение» в `Map`?](#Как-перебрать-все-пары-ключ-значение-в-map)
|
||||
+ [В чем отличия `TreeSet` и `HashSet`?](#В-чем-отличия-treeset-и-hashset)
|
||||
+ [Что будет, если добавлять элементы в `TreeSet` по возрастанию?](#Что-будет-если-добавлять-элементы-в-treeset-по-возрастанию)
|
||||
+ [Чем `LinkedHashSet` отличается от `HashSet`?](#Чем-linkedhashset-отличается-от-hashset)
|
||||
+ [Для `Enum` есть специальный класс `java.util.EnumSet`. Зачем? Чем авторов не устраивал `HashSet` или `TreeSet`?](#Для-enum-есть-специальный-класс-javautilenumset-Зачем-Чем-авторов-не-устраивал-hashset-или-treeset)
|
||||
+ [Какие существуют способы перебирать элементы списка?](#Какие-существуют-способы-перебирать-элементы-списка)
|
||||
+ [Каким образом можно получить синхронизированные объекты стандартных коллекций?](#Каким-образом-можно-получить-синхронизированные-объекты-стандартных-коллекций)
|
||||
+ [Как получить коллекцию только для чтения?](#Как-получить-коллекцию-только-для-чтения)
|
||||
+ [Напишите однопоточную программу, которая заставляет коллекцию выбросить `ConcurrentModificationException`.](#Напишите-однопоточную-программу-которая-заставляет-коллекцию-выбросить-concurrentmodificationexception)
|
||||
+ [Приведите пример, когда какая-либо коллекция выбрасывает `UnsupportedOperationException`.](#Приведите-пример-когда-какая-либо-коллекция-выбрасывает-unsupportedoperationexception)
|
||||
+ [Реализуйте симметрическую разность двух коллекций используя методы `Collection` (`addAll(...)`, `removeAll(...)`, `retainAll(...)`).](#Реализуйте-симметрическую-разность-двух-коллекций-используя-методы-collection-addall-removeall-retainall)
|
||||
+ [Как, используя LinkedHashMap, сделать кэш c «invalidation policy»?](#Как-используя-linkedhashmap-сделать-кэш-c-invalidation-policy)
|
||||
+ [Как одной строчкой скопировать элементы любой `collection` в массив?](#Как-одной-строчкой-скопировать-элементы-любой-collection-в-массив)
|
||||
+ [Как одним вызовом из `List` получить `List` со всеми элементами, кроме первых и последних 3-х?](#Как-одним-вызовом-из-list-получить-list-со-всеми-элементами-кроме-первых-и-последних-3-х)
|
||||
+ [Как одной строчкой преобразовать `HashSet` в `ArrayList`?](#Как-одной-строчкой-преобразовать-hashset-в-arraylist)
|
||||
+ [Как одной строчкой преобразовать `ArrayList` в `HashSet`?](#Как-одной-строчкой-преобразовать-arraylist-в-hashset)
|
||||
+ [Сделайте `HashSet` из ключей `HashMap`.](#Сделайте-hashset-из-ключей-hashmap)
|
||||
+ [Сделайте `HashMap` из `HashSet<Map.Entry<K, V>>`.](#Сделайте-hashmap-из-hashsetmapentryk-v)
|
||||
|
||||
##Что такое _«коллекция»_?
|
||||
_«Коллекция»_ - это структура данных, набор каких-либо объектов. Данными (объектами в наборе) могут быть числа, строки, объекты пользовательских классов и т.п.
|
||||
|
||||
[к оглавлению](#java-collections-framework)
|
||||
|
||||
##Назовите основные интерфейсы JCF и их реализации.
|
||||
На вершине иерархии в Java Collection Framework располагаются 2 интерфейса: `Collection` и `Map`. Эти интерфейсы разделяют все коллекции, входящие во фреймворк на две части по типу хранения данных: простые последовательные наборы элементов и наборы пар «ключ — значение» соответственно.
|
||||
|
||||
Интерфейс `Collection` расширяют интерфейсы:
|
||||
|
||||
+ `List` (список) представляет собой коллекцию, в которой допустимы дублирующие значения. Элементы такой коллекции пронумерованы, начиная от нуля, к ним можно обратиться по индексу. Реализации:
|
||||
+ `ArrayList` - инкапсулирует в себе обычный массив, длина которого автоматически увеличивается при добавлении новых элементов.
|
||||
+ `LinkedList` (двунаправленный связный список) - состоит из узлов, каждый из которых содержит как собственно данные, так и две ссылки на следующий и предыдущий узел.
|
||||
+ `Vector` — реализация динамического массива объектов, методы которой синхронизированы.
|
||||
+ `Stack` — реализация стека LIFO (last-in-first-out).
|
||||
+ `Set` (сет) описывает неупорядоченную коллекцию, не содержащую повторяющихся элементов. Реализации:
|
||||
+ `HashSet` - использует HashMap для хранения данных. В качестве ключа и значения используется добавляемый элемент. Из-за особенностей реализации порядок элементов не гарантируется при добавлении.
|
||||
+ `LinkedHashSet` — гарантирует, что порядок элементов при обходе коллекции будет идентичен порядку добавления элементов.
|
||||
+ `TreeSet` — предоставляет возможность управлять порядком элементов в коллекции при помощи объекта `Comparator`, либо сохраняет элементы с использованием «natural ordering».
|
||||
+ `Queue` (очередь) предназначена для хранения элементов с предопределённым способом вставки и извлечения FIFO (first-in-first-out):
|
||||
+ `PriorityQueue` — предоставляет возможность управлять порядком элементов в коллекции при помощи объекта `Comparator`, либо сохраняет элементы с использованием «natural ordering».
|
||||
+ `ArrayDeque` — реализация интерфейса `Deque`, который расширяет интерфейс `Queue` методами, позволяющими реализовать конструкцию вида LIFO (last-in-first-out).
|
||||
|
||||
Интерфейс `Map` реализован классами:
|
||||
|
||||
+ `Hashtable` — хэш-таблица, методы которой синхронизированы. Не позволяет использовать `null` в качестве значения или ключа и не является упорядоченной.
|
||||
+ `HashMap` — хэш-таблица. Позволяет использовать `null` в качестве значения или ключа и не является упорядоченной.
|
||||
+ `LinkedHashMap` — упорядоченная реализация хэш-таблицы.
|
||||
+ `TreeMap` — реализация основанная на красно-чёрных деревьях. Является упорядоченной и предоставляет возможность управлять порядком элементов в коллекции при помощи объекта `Comparator`, либо сохраняет элементы с использованием «natural ordering».
|
||||
+ `WeakHashMap` — реализация хэш-таблицы, которая организована с использованием _weak references_ для ключей (сборщик мусора автоматически удалит элемент из коллекции при следующей сборке мусора, если на ключ этого элемента нет жёстких ссылок).
|
||||
|
||||
[к оглавлению](#java-collections-framework)
|
||||
|
||||
##Расположите в виде иерархии следующие интерфейсы: `List`, `Set`, `Map`, `SortedSet`, `SortedMap`, `Collection`, `Iterable`, `Iterator`, `NavigableSet`, `NavigableMap`.
|
||||
+ `Iterable`
|
||||
+ `Collection`
|
||||
+ `List`
|
||||
+ `Set`
|
||||
+ `SortedSet`
|
||||
+ `NavigableSet`
|
||||
+ `Map`
|
||||
+ `SortedMap`
|
||||
+ `NavigableMap`
|
||||
+ `Iterator`
|
||||
|
||||
[к оглавлению](#java-collections-framework)
|
||||
|
||||
##Почему `Map` — это не `Collection`, в то время как `List` и `Set` являются `Collection`?
|
||||
`Collection` представляет собой совокупность некоторых элементов. `Map` - это совокупность пар «ключ-значение».
|
||||
|
||||
[к оглавлению](#java-collections-framework)
|
||||
|
||||
##В чем разница между классами `java.util.Collection` и `java.util.Collections`?
|
||||
`java.util.Collections` - набор статических методов для работы с коллекциями.
|
||||
|
||||
`java.util.Collection` - один из основных интерфейсов Java Collections Framework.
|
||||
|
||||
[к оглавлению](#java-collections-framework)
|
||||
|
||||
##Что такое «fail-fast поведение»?
|
||||
__fail-fast поведение__ означает, что при возникновении ошибки или состояния, которое может привести к ошибке, система немедленно прекращает дальнейшую работу и уведомляет об этом. Использование fail-fast подхода позволяет избежать недетерминированного поведения программы в течение времени.
|
||||
|
||||
В Java Collections API некоторые итераторы ведут себя как fail-fast и выбрасывают `ConcurrentModificationException`, если после его создания была произведена модификация коллекции, т.е. добавлен или удален элемент напрямую из коллекции, а не используя методы итератора.
|
||||
|
||||
Реализация такого поведения осуществляется за счет подсчета количества модификаций коллекции (modification count):
|
||||
|
||||
+ при изменении коллекции счетчик модификаций так же изменяется;
|
||||
+ при создании итератора ему передается текущее значение счетчика;
|
||||
+ при каждом обращении к итератору сохраненное значение счетчика сравнивается с текущим, и, если они не совпадают, возникает исключение.
|
||||
|
||||
[к оглавлению](#java-collections-framework)
|
||||
|
||||
##Какая разница между fail-fast и fail-safe?
|
||||
В противоположность fail-fast, итераторы fail-safe не вызывают никаких исключений при изменении структуры, потому что они работают с клоном коллекции вместо оригинала.
|
||||
|
||||
[к оглавлению](#java-collections-framework)
|
||||
|
||||
##Приведите примеры итераторов реализующих поведение fail-safe
|
||||
Итератор коллекции `CopyOnWriteArrayList` и итератор представления `keySet` коллекции `ConcurrentHashMap` являются примерами итераторов fail-safe.
|
||||
|
||||
[к оглавлению](#java-collections-framework)
|
||||
|
||||
##Чем различаются `Enumeration` и `Iterator`.
|
||||
Хотя оба интерфейса и предназначены для обхода коллекций между ними имеются существенные различия:
|
||||
|
||||
+ с помощью `Enumeration` нельзя добавлять/удалять элементы;
|
||||
+ в `Iterator` исправлены имена методов для повышения читаемости кода (`Enumeration.hasMoreElements()` соответствует `Iterator.hasNext()`, `Enumeration.nextElement()` соответствует `Iterator.next()` и т.д);
|
||||
+ `Enumeration` присутствуют в устаревших классах, таких как `Vector`/`Stack`, тогда как `Iterator` есть во всех современных классах-коллекциях.
|
||||
|
||||
[к оглавлению](#java-collections-framework)
|
||||
|
||||
##Как между собой связаны `Iterable` и `Iterator`?
|
||||
Интерфейс `Iterable` имеет только один метод - `iterator()`, который возвращает `Iterator`.
|
||||
|
||||
[к оглавлению](#java-collections-framework)
|
||||
|
||||
##Как между собой связаны `Iterable`, `Iterator` и «for-each»?
|
||||
Классы, реализующие интерфейс `Iterable`, могут применяться в конструкции `for-each`, которая использует `Iterator`.
|
||||
|
||||
[к оглавлению](#java-collections-framework)
|
||||
|
||||
##Сравните `Iterator` и `ListIterator`.
|
||||
+ `ListIterator` расширяет интерфейс `Iterator`
|
||||
+ `ListIterator` может быть использован только для перебора элементов коллекции `List`;
|
||||
+ `Iterator` позволяет перебирать элементы только в одном направлении, при помощи метода `next()`. Тогда как `ListIterator` позволяет перебирать список в обоих направлениях, при помощи методов `next()` и `previous()`;
|
||||
+ `ListIterator` не указывает на конкретный элемент: его текущая позиция располагается между элементами, которые возвращают методы `previous()` и `next()`.
|
||||
+ При помощи `ListIterator` вы можете модифицировать список, добавляя/удаляя элементы с помощью методов `add()` и `remove()`. `Iterator` не поддерживает данного функционала.
|
||||
|
||||
[к оглавлению](#java-collections-framework)
|
||||
|
||||
##Что произойдет при вызове `Iterator.next()` без предварительного вызова `Iterator.hasNext()`?
|
||||
Если итератор указывает на последний элемент коллекции, то возникнет исключение `NoSuchElementException`, иначе будет возвращен следующий элемент.
|
||||
|
||||
[к оглавлению](#java-collections-framework)
|
||||
|
||||
##Сколько элементов будет пропущено, если `Iterator.next()` будет вызван после 10-ти вызовов `Iterator.hasNext()`?
|
||||
Нисколько - `hasNext()` осуществляет только проверку наличия следующего элемента.
|
||||
|
||||
[к оглавлению](#java-collections-framework)
|
||||
|
||||
##Как поведёт себя коллекция, если вызвать `iterator.remove()`?
|
||||
Если вызову `iterator.remove()` предшествовал вызов `iterator.next()`, то `iterator.remove()` удалит элемент коллекции, на который указывает итератор, в противном случае будет выброшено `IllegalStateException()`.
|
||||
|
||||
[к оглавлению](#java-collections-framework)
|
||||
|
||||
##Как поведёт себя уже инстанциированный итератор для `collection`, если вызвать `collection.remove()`?
|
||||
При следующем вызове методов итератора будет выброшено `ConcurrentModificationException`.
|
||||
|
||||
[к оглавлению](#java-collections-framework)
|
||||
|
||||
##Как избежать `ConcurrentModificationException` во время перебора коллекции?
|
||||
+ Попробовать подобрать другой итератор, работающий по принципу fail-safe. К примеру, для `List` можно использовать `ListIterator`.
|
||||
+ Использовать `ConcurrentHashMap` и `CopyOnWriteArrayList`.
|
||||
+ Преобразовать список в массив и перебирать массив.
|
||||
+ Блокировать изменения списка на время перебора с помощью блока `synchronized`.
|
||||
|
||||
Отрицательная сторона последних двух вариантов - ухудшение производительности.
|
||||
|
||||
[к оглавлению](#java-collections-framework)
|
||||
|
||||
##Какая коллекция реализует дисциплину обслуживания FIFO?
|
||||
FIFO, First-In-First-Out («первым пришел-первым ушел») - по этому принципу построена коллекция `Queue`.
|
||||
|
||||
[к оглавлению](#java-collections-framework)
|
||||
|
||||
##Какая коллекция реализует дисциплину обслуживания FILO?
|
||||
FILO, First-In-Last-Out («первым пришел, последним ушел») - по этому принципу построена коллекция `Stack`.
|
||||
|
||||
[к оглавлению](#java-collections-framework)
|
||||
|
||||
##Чем отличается `ArrayList` от `Vector`?
|
||||
##Зачем добавили `ArrayList`, если уже был `Vector`?
|
||||
+ Методы класса `Vector` синхронизированы, а `ArrayList` - нет;
|
||||
+ По умолчанию, `Vector` удваивает свой размер, когда заканчивается выделенная под элементы память. `ArrayList` же увеличивает свой размер только на половину.
|
||||
|
||||
`Vector` это устаревший класс и его использование не рекомендовано.
|
||||
|
||||
[к оглавлению](#java-collections-framework)
|
||||
|
||||
##Чем отличается `ArrayList` от `LinkedList`? В каких случаях лучше использовать первый, а в каких второй?
|
||||
`ArrayList` это список, реализованный на основе массива, а `LinkedList` — это классический двусвязный список, основанный на объектах с ссылками между ними.
|
||||
|
||||
`ArrayList`:
|
||||
|
||||
+ доступ к произвольному элементу по индексу за время _O(1)_;
|
||||
+ доступ к элементам по значению за линейное время _O(N)_;
|
||||
+ вставка в конец в среднем производится за время _O(1)_;
|
||||
+ удаление произвольного элемента из списка занимает значительное время т.к. при этом все элементы находящиеся «правее» смещаются на одну ячейку влево (реальный размер массива (capacity) не изменяется);
|
||||
+ вставка элемента в произвольное место списка занимает значительное время т.к. при этом все элементы находящиеся «правее» смещаются на одну ячейку вправо;
|
||||
+ минимум накладных расходов при хранении.
|
||||
|
||||
`LinkedList`:
|
||||
|
||||
+ на получение элемента по индексу или значению потребуется линейное время _O(N)_;
|
||||
+ на добавление и удаление в начало или конец списка потребуется _O(1)_;
|
||||
+ вставка или удаление в/из произвольного место _O(N)_;
|
||||
+ требует больше памяти для хранения такого же количества элементов, потому что кроме самого элемента хранятся еще указатели на следующий и предыдущий элементы списка.
|
||||
|
||||
В целом, `LinkedList` в абсолютных величинах проигрывает `ArrayList` и по потребляемой памяти и по скорости выполнения операций. `LinkedList` предпочтительно применять, когда нужны частые операции вставки/удаления или в случаях, когда необходимо гарантированное время добавления элемента в список.
|
||||
|
||||
[к оглавлению](#java-collections-framework)
|
||||
|
||||
##Что работает быстрее `ArrayList` или `LinkedList`?
|
||||
Смотря какие действия будут выполняться над структурой.
|
||||
|
||||
см. [Чем отличается `ArrayList` от `LinkedList`](#Чем-отличается-arraylist-от-linkedlist-В-каких-случаях-лучше-использовать-первый-а-в-каких-второй)
|
||||
|
||||
[к оглавлению](#java-collections-framework)
|
||||
|
||||
##Какое худшее время работы метода `contains()` для элемента, который есть в `LinkedList`?
|
||||
_O(N)_. Время поиска элемента линейно пропорционально количеству элементов с списке.
|
||||
|
||||
[к оглавлению](#java-collections-framework)
|
||||
|
||||
##Какое худшее время работы метода `contains()` для элемента, который есть в `ArrayList`?
|
||||
_O(N)_. Время поиска элемента линейно пропорционально количеству элементов с списке.
|
||||
|
||||
[к оглавлению](#java-collections-framework)
|
||||
|
||||
##Какое худшее время работы метода `add()` для `LinkedList`?
|
||||
_O(N)_. Добавление в начало/конец списка осуществляется за время _O(1)_.
|
||||
|
||||
[к оглавлению](#java-collections-framework)
|
||||
|
||||
##Какое худшее время работы метода `add()` для `ArrayList`?
|
||||
_O(N)_. Вставка элемента в конец списка осуществляется за время _O(1)_, но если вместимость массива недостаточна, то происходит создание нового массива с увеличенным размером и копирование всех элементов из старого массива в новый.
|
||||
|
||||
[к оглавлению](#java-collections-framework)
|
||||
|
||||
##Необходимо добавить 1 млн. элементов, какую структуру вы используете?
|
||||
Однозначный ответ можно дать только исходя из информации о том в какую часть списка происходит добавление элементов, что потом будет происходить с элементами списка, существуют ли какие-то ограничения по памяти или скорости выполнения.
|
||||
|
||||
см. [Чем отличается `ArrayList` от `LinkedList`](#Чем-отличается-arraylist-от-linkedlist-В-каких-случаях-лучше-использовать-первый-а-в-каких-второй)
|
||||
|
||||
[к оглавлению](#java-collections-framework)
|
||||
|
||||
##Как происходит удаление элементов из `ArrayList`? Как меняется в этом случае размер `ArrayList`?
|
||||
|
||||
При удалении произвольного элемента из списка, все элементы находящиеся «правее» смещаются на одну ячейку влево и реальный размер массива (его емкость, capacity) не изменяется никак. Механизм автоматического «расширения» массива существует, а вот автоматического «сжатия» нет, можно только явно выполнить «сжатие» командой `trimToSize()`.
|
||||
|
||||
[к оглавлению](#java-collections-framework)
|
||||
|
||||
##Предложите эффективный алгоритм удаления нескольких рядом стоящих элементов из середины списка, реализуемого `ArrayList`.
|
||||
Допустим нужно удалить `n` элементов с позиции `m` в списке. Вместо выполнения удаления одного элемента `n` раз (каждый раз смещая на 1 позицию элементы, стоящие «правее» в списке), нужно выполнить смещение всех элементов, стоящих «правее» `n + m` позиции на `n` элементов «левее» к началу списка. Таким образом, вместо выполнения `n` итераций перемещения элементов списка, все выполняется за 1 проход.
|
||||
|
||||
[к оглавлению](#java-collections-framework)
|
||||
|
||||
##Сколько необходимо дополнительной памяти при вызове `ArrayList.add()`?
|
||||
Если в массиве достаточно места для размещения нового элемента, то дополнительной памяти не требуется. Иначе происходит создание нового массива размером в 1,5 раза превышающим существующий (это верно для JDK выше 1.7, в более ранних версиях размер увеличения иной).
|
||||
|
||||
[к оглавлению](#java-collections-framework)
|
||||
|
||||
##Сколько выделяется дополнительно памяти при вызове `LinkedList.add()`?
|
||||
Создается один новый экземпляр вложенного класса `Node`.
|
||||
|
||||
[к оглавлению](#java-collections-framework)
|
||||
|
||||
##Оцените количество памяти на хранение одного примитива типа `byte` в `LinkedList`?
|
||||
Каждый элемент `LinkedList` хранит ссылку на предыдущий элемент, следующий элемент и ссылку на данные.
|
||||
|
||||
```java
|
||||
private static class Node<E> {
|
||||
E item;
|
||||
Node<E> next;
|
||||
Node<E> prev;
|
||||
//...
|
||||
}
|
||||
```
|
||||
|
||||
Для 32-битных систем каждая ссылка занимает 32 бита (4 байта). Сам объект (заголовок) вложенного класса `Node` занимает 8 байт. 4 + 4 + 4 + 8 = 20 байт, а т.к. размер каждого объекта в Java кратен 8, соответственно получаем 24 байта. Примитив типа `byte` занимает 1 байт памяти, но в JCF примитивы упаковываются: объект типа `Byte` занимает в памяти 16 байт (8 байт на заголовок объекта, 1 байт на поле типа `byte` и 7 байт для кратности 8). Также напомню, что значения от -128 до 127 кэшируются и для них новые объекты каждый раз не создаются. Таким образом, в x32 JVM 24 байта тратятся на хранение одного элемента в списке и 16 байт - на хранение упакованного объекта типа `Byte`. Итого 40 байт.
|
||||
|
||||
Для 64-битной JVM каждая ссылка занимает 64 бита (8 байт), размер заголовка каждого объекта составляет 16 байт (два машинных слова). Вычисления аналогичны: 8 + 8 + 8 + 16 = 40байт и 24 байта. Итого 64 байта.
|
||||
|
||||
[к оглавлению](#java-collections-framework)
|
||||
|
||||
##Оцените количество памяти на хранение одного примитива типа `byte` в `ArrayList`?
|
||||
`ArrayList` основан на массиве, для примитивных типов данных осуществляется автоматическая упаковка значения, поэтому 16 байт тратится на хранение упакованного объекта и 4 байта (8 для x64) - на хранение ссылки на этот объект в самой структуре данных. Таким образом, в x32 JVM 4 байта используются на хранение одного элемента и 16 байт - на хранение упакованного объекта типа `Byte`. Для x64 - 8 байт и 24 байта соотвтетсвенно.
|
||||
|
||||
[к оглавлению](#java-collections-framework)
|
||||
|
||||
##Для `ArrayList` или для `LinkedList` операция добавления элемента в середину (`list.add(list.size()/2, newElement)`) медленнее?
|
||||
Для `ArrayList`:
|
||||
|
||||
+ проверка массива на вместимость. Если вместимости недостаточно, то увеличение размера массива и копирование всех элементов в новый массив (_O(N)_);
|
||||
+ копирование всех элементов, расположенных правее от позиции вставки, на одну позицию вправо (_O(N)_);
|
||||
+ вставка элемента (_O(1)_).
|
||||
|
||||
Для `LinkedList`:
|
||||
|
||||
+ поиск позиции вставки (_O(N)_);
|
||||
+ вставка элемента (_O(1)_).
|
||||
|
||||
В худшем случае вставка в середину списка эффективнее для `LinkedList`. В остальных - скорее всего, для `ArrayList`, поскольку копирование элементов осуществляется за счет вызова быстрого системного метода `System.arraycopy()`.
|
||||
|
||||
[к оглавлению](#java-collections-framework)
|
||||
|
||||
##В реализации класса `ArrayList` есть следующие поля: `Object[] elementData`, `int size`. Объясните, зачем хранить отдельно `size`, если всегда можно взять `elementData.length`?
|
||||
Размер массива `elementData` представляет собой вместимость (capacity) `ArrayList`, которая всегда больше переменной `size` - реального количества хранимых элементов. При необходимости вместимость автоматически возрастает.
|
||||
|
||||
[к оглавлению](#java-collections-framework)
|
||||
|
||||
##Сравните интерфейсы `Queue` и `Deque`.
|
||||
##Кто кого расширяет: `Queue` расширяет `Deque`, или `Deque` расширяет `Queue`?
|
||||
`Queue` - это очередь, которая обычно (но необязательно) строится по принципу FIFO (First-In-First-Out) - соответственно извлечение элемента осуществляется с начала очереди, вставка элемента - в конец очереди. Хотя этот принцип нарушает, к примеру `PriorityQueue`, использующая «natural ordering» или переданный `Comparator` при вставке нового элемента.
|
||||
|
||||
`Deque` (Double Ended Queue) расширяет `Queue` и согласно документации это линейная коллекция, поддерживающая вставку/извлечение элементов с обоих концов. Помимо этого реализации интерфейса `Deque` могут строится по принципу FIFO, либо LIFO.
|
||||
|
||||
Реализации и `Deque`, и `Queue` обычно не переопределяют методы `equals()` и `hashCode()`, вместо этого используются унаследованные методы класса Object, основанные на сравнении ссылок.
|
||||
|
||||
[к оглавлению](#java-collections-framework)
|
||||
|
||||
##Почему `LinkedList` реализует и `List`, и `Deque`?
|
||||
`LinkedList` позволяет добавлять элементы в начало и конец списка за константное время, что хорошо согласуется с поведением интерфейса `Deque`.
|
||||
|
||||
[к оглавлению](#java-collections-framework)
|
||||
|
||||
##`LinkedList` — это односвязный, двусвязный или четырехсвязный список?
|
||||
`Двусвязный`: каждый элемент `LinkedList` хранит ссылку на предыдущий и следующий элементы.
|
||||
|
||||
[к оглавлению](#java-collections-framework)
|
||||
|
||||
##Как перебрать элементы `LinkedList` в обратном порядке, не используя медленный `get(index)`?
|
||||
Для этого в `LinkedList` есть обратный итератор, который можно получить вызва метод `descendingIterator()`.
|
||||
|
||||
[к оглавлению](#java-collections-framework)
|
||||
|
||||
##Что позволяет сделать `PriorityQueue`?
|
||||
Особенностью `PriorityQueue` является возможность управления порядком элементов. По-умолчанию, элементы сортируются с использованием «natural ordering», но это поведение может быть переопределено при помощи объекта `Comparator`, который задаётся при создании очереди. Данная коллекция не поддерживает null в качестве элементов.
|
||||
|
||||
Используя `PriorityQueue`, можно, например, реализовать алгоритм Дейкстры для поиска кратчайшего пути от одной вершины графа к другой. Либо для хранения объектов согласно определённого свойства.
|
||||
|
||||
[к оглавлению](#java-collections-framework)
|
||||
|
||||
##`Stack` считается «устаревшим». Чем его рекомендуют заменять? Почему?
|
||||
`Stack` был добавлен в Java 1.0 как реализация стека LIFO (last-in-first-out) и является расширением коллекции `Vector`, хотя это несколько нарушает понятие стека (например, класс `Vector` предоставляет возможность обращаться к любому элементу по индексу). Является частично синхронизированной коллекцией (кроме метода добавления `push()`) с вытекающими отсюда последствиями в виде негативного воздействия на производительность. После добавления в Java 1.6 интерфейса `Deque`, рекомендуется использовать реализации именно этого интерфейса, например `ArrayDeque`.
|
||||
|
||||
[к оглавлению](#java-collections-framework)
|
||||
|
||||
##Зачем нужен `HashMap`, если есть `Hashtable`?
|
||||
+ Методы класса `Hashtable` синхронизированы, что приводит к снижению производительности, а `HashMap` - нет;
|
||||
+ `HashTable` не может содержать элементы `null`, тогда как `HashMap` может содержать один ключ `null` и любое количество значений `null`;
|
||||
+ Iterator у `HashMap`, в отличие от Enumeration у `HashTable`, работает по принципу «fail-fast» (выдает исключение при любой несогласованности данных).
|
||||
|
||||
`Hashtable` это устаревший класс и его использование не рекомендовано.
|
||||
|
||||
[к оглавлению](#java-collections-framework)
|
||||
|
||||
##В чем разница между `HashMap` и `IdentityHashMap`? Для чего нужна `IdentityHashMap`?
|
||||
`IdentityHashMap` - это структура данных, так же реализующая интерфейс `Map` и использующая при сравнении ключей (значений) сравнение ссылок, а не вызов метода `equals()`. Другими словами, в `IdentityHashMap` два ключа `k1` и `k2` будут считаться равными, если они указывают на один объект, т.е. выполняется условие `k1` == `k2`.
|
||||
|
||||
`IdentityHashMap` не использует метод `hashCode()`, вместо которого применяется метод `System.identityHashCode()`, по этой причине `IdentityHashMap` по сравнению с `HashMap` имеет более высокую производительность, особенно если последний хранит объекты с дорогостоящими методами `equals()` и `hashCode()`.
|
||||
|
||||
Одним из основных требований к использованию `HashMap` является неизменяемость ключа, а, т.к. `IdentityHashMap` не использует методы `equals()` и `hashCode()`, то это правило на него не распространяется.
|
||||
|
||||
`IdentityHashMap` может применяться для реализации сериализации/клонирования. При выполнении подобных алгоритмов программе необходимо обслуживать хэш-таблицу со всеми ссылками на объекты, которые уже были обработаны. Такая структура не должна рассматривать уникальные объекты как равные, даже если метод `equals()` возвращает `true`.
|
||||
|
||||
[к оглавлению](#java-collections-framework)
|
||||
|
||||
##В чем разница между `HashMap` и `WeakHashMap`? Для чего используется `WeakHashMap`?
|
||||
В Java существует 4 типа ссылок: _сильные (strong reference)_, _мягкие (SoftReference)_, _слабые (WeakReference)_ и _фантомные (PhantomReference)_. Особенности каждого типа ссылок связаны с работой Garbage Collector. Если объект можно достичь только с помощью цепочки WeakReference (то есть на него отсутствуют сильные и мягкие ссылки), то данный объект будет помечен на удаление.
|
||||
|
||||
`WeakHashMap` - это структура данных, реализующая интерфейс `Map` и основанная на использовании WeakReference для хранения ключей. Таким образом, пара «ключ-значение» будет удалена из `WeakHashMap`, если на объект-ключ более не имеется сильных ссылок.
|
||||
|
||||
В качестве примера использования такой структуры данных можно привести следующую ситуацию: допустим имеются объекты, которые необходимо расширить дополнительной информацией, при этом изменение класса этих объектов нежелательно либо невозможно. В этом случае добавляем каждый объект в `WeakHashMap` в качестве ключа, а в качестве значения - нужную информацию. Таким образом, пока на объект имеется сильная ссылка (либо мягкая), можно проверять хэш-таблицу и извлекать информацию. Как только объект будет удален, то WeakReference для этого ключа будет помещен в ReferenceQueue и затем соответствующая запись для этой слабой ссылки будет удалена из `WeakHashMap`.
|
||||
|
||||
[к оглавлению](#java-collections-framework)
|
||||
|
||||
##В `WeakHashMap` используются WeakReferences. А почему бы не создать `SoftHashMap` на SoftReferences?
|
||||
`SoftHashMap` представлена в сторонних библиотеках, например, в `Apache Commons`.
|
||||
|
||||
[к оглавлению](#java-collections-framework)
|
||||
|
||||
##В `WeakHashMap` используются WeakReferences. А почему бы не создать `PhantomHashMap` на PhantomReferences?
|
||||
PhantomReference при вызове метода `get()` возвращает всегда `null`, поэтому тяжело представить назначение такой структуры данных.
|
||||
|
||||
[к оглавлению](#java-collections-framework)
|
||||
|
||||
##`LinkedHashMap` - что в нем от `LinkedList`, а что от `HashMap`?
|
||||
Реализация `LinkedHashMap` отличается от `HashMap` поддержкой двухсвязанного списка, определяющего порядок итерации по элементам структуры данных. По умолчанию элементы списка упорядочены согласно их порядку добавления в `LinkedHashMap` (insertion-order). Однако порядок итерации можно изменить, установив параметр конструктора `accessOrder` в значение `true`. В этом случае доступ осуществляется по порядку последнего обращения к элементу (access-order). Это означает, что при вызове методов `get()` или `put()` элемент, к которому обращаемся, перемещается в конец списка.
|
||||
|
||||
При добавлении элемента, который уже присутствует в `LinkedHashMap` (т.е. с одинаковым ключом), порядок итерации по элементам не изменяется.
|
||||
|
||||
[к оглавлению](#java-collections-framework)
|
||||
|
||||
##В чем проявляется «сортированность» `SortedMap`, кроме того, что `toString()` выводит все элементы по порядку?
|
||||
Так же оно проявляется при итерации по коллекции.
|
||||
|
||||
[к оглавлению](#java-collections-framework)
|
||||
|
||||
##Как устроен `HashMap`?
|
||||
`HashMap` состоит из «корзин» (bucket). С технической точки зрения «корзины» — это элементы массива, которые хранят ссылки на списки элементов. При добавлении новой пары «ключ-значение», вычисляет хэш-код ключа, на основании которого вычисляется номер корзины (номер ячейки массива), в которую попадет новый элемент. Если корзина пустая, то в нее сохраняется ссылка на вновь добавляемый элемент, если же там уже есть элемент, то происходит последовательный переход по ссылкам между элементами в цепочке, в поисках последнего элемента, от которого и ставится ссылка на вновь добавленный элемент. Если в списке был найден элемент с таким же ключом, то он заменяется.
|
||||
|
||||
[к оглавлению](#java-collections-framework)
|
||||
|
||||
##Согласно Кнуту и Кормену существует две основных реализации хэш-таблицы: на основе открытой адресации и на основе метода цепочек. Как реализована `HashMap`? Почему, по вашему мнению, была выбрана именно эта реализация? В чем плюсы и минусы каждого подхода?
|
||||
`HashMap` реализован с использованием метода цепочек, т.е. каждой ячейке массива (корзине) соответствует свой связный список и при возникновении коллизии осуществляется добавление нового элемента в этот список.
|
||||
|
||||
Для метода цепочек коэффициент заполнения может быть больше 1 и с увеличением числа элементов производительность убывает линейно. Такие таблицы удобно использовать, если заранее неизвестно количество хранимых элементов, либо их может быть достаточно много, что приводит к большим значениям коэффициента заполнения.
|
||||
|
||||
Среди методов открытой реализации различают:
|
||||
|
||||
+ линейное пробирование;
|
||||
+ квадратичное пробирование;
|
||||
+ двойное хэширование.
|
||||
|
||||
Недостатки структур с методом открытой адресации:
|
||||
|
||||
+ Количество элементов в хэш-таблице не может превышать размера массива. По мере увеличения числа элементов и повышения коэффициента заполнения производительность структуры резко падает, поэтому необходимо проводить перехэширование.
|
||||
+ Сложно организовать удаление элемента.
|
||||
+ Первые два метода открытой адресации приводят к проблеме первичной и вторичной группировок.
|
||||
|
||||
Преимущества хэш-таблицы с открытой адресацией:
|
||||
|
||||
+ отсутствие затрат на создание и хранение объектов списка;
|
||||
+ простота организации сериализации/десериализации объекта.
|
||||
|
||||
[к оглавлению](#java-collections-framework)
|
||||
|
||||
##Как работает `HashMap` при попытке сохранить в него два элемента по ключам с одинаковым `hashCode()`, но для которых `equals() == false`?
|
||||
По значению `hashCode()` вычисляется индекс ячейки массива, в список которой этот элемент будет добавлен. Перед добавлением осуществляется проверка на наличие элементов в этой ячейке. Если элементы с таким `hashCode()` уже присутствует, то осуществляется обход списка со сравнением по `equals()` в поисках идентичного элемента. Т.к. `equals() == false`, - элемент будет добавлен в начало списка.
|
||||
|
||||
[к оглавлению](#java-collections-framework)
|
||||
|
||||
##Какое начальное количество корзин в `HashMap`?
|
||||
В конструкторе по умолчанию - 16, используя конструкторы с параметрами можно задавать произвольное начальное количество корзин.
|
||||
|
||||
[к оглавлению](#java-collections-framework)
|
||||
|
||||
##Какова оценка временной сложности операций над элементами из `HashMap`? Гарантирует ли `HashMap` указанную сложность выборки элемента?
|
||||
В общем случае операции добавления, поиска и удаления элементов занимают константное время.
|
||||
|
||||
Данная сложность не гарантируется, т.к. если хэш-функция будет распределяет элементы по корзинам равномерно, временная сложность станет не хуже _O(lg(N))_, а в случае, когда хэш-функция постоянно возвращает одно и то же значение `HashMap` превратится в связный список со сложностью О(n) .
|
||||
|
||||
[к оглавлению](#java-collections-framework)
|
||||
|
||||
##Возможна ли ситуация, когда `HashMap` выродится в список даже с ключами имеющими разные `hashCode()`?
|
||||
Это возможно в случае, если метод, определяющий номер корзины будет возвращать одинаковые значения.
|
||||
|
||||
[к оглавлению](#java-collections-framework)
|
||||
|
||||
##В каком случае может быть потерян элемент в `HashMap`?
|
||||
Допустим, в качестве ключа используется не примитив, а объект с несколькими полями. После добавления элемента в `HashMap` у объекта, который выступает в качестве ключа, изменяют одно поле, которое участвует в вычислении хэш-кода. В результате при попытке найти данный элемент по исходному ключу, будет происходить обращение к правильной корзине, а вот `equals` уже не найдет указанный ключ в списке элементов. Тем не менее, даже если `equals` реализован таким образом, что изменение данного поля объекта не влияет на результат, то после увеличения размера корзин и пересчета хэш-кодов элементов, указанный элемент, с измененным значением поля, с большой долей вероятности попадет в совершенно другую корзину и тогда уже потеряется совсем.
|
||||
|
||||
[к оглавлению](#java-collections-framework)
|
||||
|
||||
##Почему нельзя использовать `byte[]` в качестве ключа в `HashMap`?
|
||||
Хэш-код массива не зависит от хранимых в нем элементов, а присваивается при создании массива (метод вычисления хэш-кода массива не переопределен и вычисляется по стандартному `Object.hashCode()` на основании адреса массива). Так же у массивов не переопределен `equals` и выполняется сравнение указателей. Это приводит к тому, что обратиться к сохраненному с ключом-массивом элементу не получится при использовании другого массива такого же размера и с такими же элементами, доступ можно осуществить лишь в одном случае — при использовании той же самой ссылки на массив, что использовалась для сохранения элемента.
|
||||
|
||||
[к оглавлению](#java-collections-framework)
|
||||
|
||||
##Какова роль `equals()` и `hashCode()` в `HashMap`?
|
||||
`hashCode` позволяет определить корзину для поиска элемента, а `equals` используется для сравнения ключей элементов в списке корзины и искомого ключа.
|
||||
|
||||
[к оглавлению](#java-collections-framework)
|
||||
|
||||
##Каково максимальное число значений `hashCode()`?
|
||||
Число значений следует из сигнатуры `int hashCode()` и равно диапазону типа `int` — __2<sup>32</sup>__.
|
||||
|
||||
[к оглавлению](#java-collections-framework)
|
||||
|
||||
##Какое худшее время работы метода get(key) для ключа, которого нет в `HashMap`?
|
||||
##Какое худшее время работы метода get(key) для ключа, который есть в `HashMap`?
|
||||
___O(N)___. Худший случай - это поиск ключа в `HashMap`, вырожденного в список по причине совпадения ключей по `hashCode()` и для выяснения хранится ли элемент с определённым ключом может потребоваться перебор всего списка.
|
||||
|
||||
[к оглавлению](#java-collections-framework)
|
||||
|
||||
##Сколько переходов происходит в момент вызова `HashMap.get(key)` по ключу, который есть в таблице?
|
||||
+ ключ равен `null`: __1__ - выполняется единственный метод `getForNullKey()`.
|
||||
+ любой ключ отличный от `null`: __4__ - вычисление хэш-кода ключа; определение номера корзины; поиск значения; возврат значения.
|
||||
|
||||
[к оглавлению](#java-collections-framework)
|
||||
|
||||
##Сколько создается новых объектов, когда вы добавляете новый элемент в `HashMap`?
|
||||
__Один__ новый объект статического вложенного класса `Entry<K,V>`.
|
||||
|
||||
[к оглавлению](#java-collections-framework)
|
||||
|
||||
##Как и когда происходит увеличение количества корзин в `HashMap`?
|
||||
Помимо `capacity` у `HashMap` есть еще поле `loadFactor`, на основании которого, вычисляется предельное количество занятых корзин `capacity * loadFactor`. По умолчанию `loadFactor = 0.75`. По достижению предельного значения, число корзин увеличивается в 2 раза и для всех хранимых элементов вычисляется новое «местоположение» с учетом нового числа корзин.
|
||||
|
||||
[к оглавлению](#java-collections-framework)
|
||||
|
||||
##Объясните смысл параметров в конструкторе `HashMap(int initialCapacity, float loadFactor)`.
|
||||
+ `initialCapacity` - исходный размер `HashMap`, количество корзин в хэш-таблице в момент её создания.
|
||||
+ `loadFactor` - коэффициент заполнения `HashMap`, при превышении которого происходит увеличение количества корзин и автоматическое перехэширование. Равен отношению числа уже хранимых элементов в таблице к её размеру.
|
||||
|
||||
[к оглавлению](#java-collections-framework)
|
||||
|
||||
##Будет ли работать `HashMap`, если все добавляемые ключи будут иметь одинаковый `hashCode()`?
|
||||
Да, будет, но в этом случае `HashMap` вырождается в связный список и теряет свои преимущества.
|
||||
|
||||
##Как перебрать все ключи `Map`?
|
||||
Использовать метод `keySet()`, который возвращает множество `Set<K>` ключей.
|
||||
|
||||
[к оглавлению](#java-collections-framework)
|
||||
|
||||
##Как перебрать все значения `Map`?
|
||||
Использовать метод `values()`, который возвращает коллекцию `Collection<V>` значений.
|
||||
|
||||
[к оглавлению](#java-collections-framework)
|
||||
|
||||
##Как перебрать все пары «ключ-значение» в `Map`?
|
||||
Использовать метод `entrySet()`, который возвращает множество `Set<Map.Entry<K, V>` пар «ключ-значение».
|
||||
|
||||
[к оглавлению](#java-collections-framework)
|
||||
|
||||
##В чем отличия `TreeSet` и `HashSet`?
|
||||
`TreeSet` обеспечивает упорядоченно хранение элементов в виде красно-черного дерева. Сложность выполнения основных операций не хуже _O(lg(N))_.
|
||||
|
||||
`HashSet` использует для хранения элементов такой же подход, что и `HashMap`, за тем отличием, что в `HashSet` в качестве ключа и значения выступает сам `элемент`, кроме того `HashSet` не поддерживает упорядоченное хранение элементов и обеспечивает временную сложность выполнения операций аналогично `HashMap`.
|
||||
|
||||
[к оглавлению](#java-collections-framework)
|
||||
|
||||
##Что будет, если добавлять элементы в `TreeSet` по возрастанию?
|
||||
В основе `TreeSet` лежит красно-черное дерево, которое умеет само себя балансировать. В итоге, `TreeSet` все равно в каком порядке вы добавляете в него элементы, преимущества этой структуры данных будут сохраняться.
|
||||
|
||||
[к оглавлению](#java-collections-framework)
|
||||
|
||||
##Чем `LinkedHashSet` отличается от `HashSet`?
|
||||
`LinkedHashSet` отличается от `HashSet` только тем, что в его основе лежит `LinkedHashMap` вместо `HashMap`. Благодаря этому порядок элементов при обходе коллекции является идентичным порядку добавления элементов (insertion-order). При добавлении элемента, который уже присутствует в `LinkedHashSet` (т.е. с одинаковым ключом), порядок обхода элементов не изменяется.
|
||||
|
||||
[к оглавлению](#java-collections-framework)
|
||||
|
||||
##Для `Enum` есть специальный класс `java.util.EnumSet`. Зачем? Чем авторов не устраивал `HashSet` или `TreeSet`?
|
||||
`EnumSet` - это реализация интерфейса `Set` для использования с перечислениями (`Enum`). В структуре данных хранятся объекты только одного типа `Enum`, указываемого при создании. Для хранения значений `EnumSet` использует массив битов (_bit vector_), - это позволяет получить высокую компактность и эффективность. Проход по `EnumSet` осуществляется согласно порядку объявления элементов перечисления.
|
||||
|
||||
Все основные операции выполняются за _O(1)_ и обычно (но негарантированно) быстрей аналогов из `HashSet`, а пакетные операции (_bulk operations_), такие как `containsAll()` и `retainAll()` выполняются даже горазда быстрей.
|
||||
|
||||
Помимо всего `EnumSet` предоставляет множество статических методов инициализации для упрощенного и удобного создания экземпляров.
|
||||
|
||||
[к оглавлению](#java-collections-framework)
|
||||
|
||||
##Какие существуют способы перебирать элементы списка?
|
||||
+ Цикл с итератором
|
||||
|
||||
```java
|
||||
Iterator<String> iterator = list.iterator();
|
||||
while (iterator.hasNext()) {
|
||||
//iterator.next();
|
||||
}
|
||||
```
|
||||
|
||||
+ Цикл `for`
|
||||
|
||||
```java
|
||||
for (int i = 0; i < list.size(); i++) {
|
||||
//list.get(i);
|
||||
}
|
||||
```
|
||||
|
||||
+ Цикл `while`
|
||||
|
||||
```java
|
||||
int i = 0;
|
||||
while (i < list.size()) {
|
||||
//list.get(i);
|
||||
i++;
|
||||
}
|
||||
```
|
||||
|
||||
+ «for-each»
|
||||
|
||||
```java
|
||||
for (String element : list) {
|
||||
//element;
|
||||
}
|
||||
```
|
||||
|
||||
[к оглавлению](#java-collections-framework)
|
||||
|
||||
##Каким образом можно получить синхронизированные объекты стандартных коллекций?
|
||||
С помощью статических методов `synchronizedMap()` и `synchronizedList()` класса `Collections`. Данные методы возвращают синхронизированный декоратор переданной коллекции. При этом все равно в случае обхода по коллекции требуется ручная синхронизация.
|
||||
|
||||
```java
|
||||
Map m = Collections.synchronizedMap(new HashMap());
|
||||
List l = Collections.synchronizedList(new ArrayList());
|
||||
```
|
||||
|
||||
Начиная с Java 6 JCF был расширен специальными коллекциями, поддерживающими многопоточный доступ, такими как `CopyOnWriteArrayList` и `ConcurrentHashMap`.
|
||||
|
||||
[к оглавлению](#java-collections-framework)
|
||||
|
||||
##Как получить коллекцию только для чтения?
|
||||
При помощи:
|
||||
|
||||
+ `Collections.unmodifiableList(list)`;
|
||||
+ `Collections.unmodifiableSet(set)`;
|
||||
+ `Collections.unmodifiableMap(map)`.
|
||||
|
||||
Эти методы принимают коллекцию в качестве параметра, и возвращают коллекцию только для чтения с теми же элементами внутри.
|
||||
|
||||
[к оглавлению](#java-collections-framework)
|
||||
|
||||
##Напишите однопоточную программу, которая заставляет коллекцию выбросить `ConcurrentModificationException`.
|
||||
```java
|
||||
public static void main(String[] args) {
|
||||
List<Integer> list = new ArrayList<>();
|
||||
list.add(1);
|
||||
list.add(2);
|
||||
list.add(3);
|
||||
|
||||
for (Integer integer : list) {
|
||||
list.remove(1);
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
[к оглавлению](#java-collections-framework)
|
||||
|
||||
##Приведите пример, когда какая-либо коллекция выбрасывает `UnsupportedOperationException`.
|
||||
```java
|
||||
public static void main(String[] args) {
|
||||
List<Integer> list = Collections.emptyList();
|
||||
list.add(0);
|
||||
}
|
||||
```
|
||||
|
||||
[к оглавлению](#java-collections-framework)
|
||||
|
||||
##Реализуйте симметрическую разность двух коллекций используя методы `Collection` (`addAll(...)`, `removeAll(...)`, `retainAll(...)`).
|
||||
Симметрическая разность двух коллекций - это множество элементов, одновременно не принадлежащих обоим исходным коллекциям.
|
||||
|
||||
```java
|
||||
<T> Collection<T> symmetricDifference(Collection<T> a, Collection<T> b) {
|
||||
// Объединяем коллекции.
|
||||
Collection<T> result = new ArrayList<>(a);
|
||||
result.addAll(b);
|
||||
|
||||
// Получаем пересечение коллекций.
|
||||
Collection<T> intersection = new ArrayList<>(a);
|
||||
intersection.retainAll(b);
|
||||
|
||||
// Удаляем элементы, расположенные в обоих коллекциях.
|
||||
result.removeAll(intersection);
|
||||
|
||||
return result;
|
||||
}
|
||||
```
|
||||
[к оглавлению](#java-collections-framework)
|
||||
|
||||
##Как, используя LinkedHashMap, сделать кэш c «invalidation policy»?
|
||||
Необходимо использовать _LRU-алгоритм (Least Recently Used algorithm)_ и `LinkedHashMap` с access-order. В этом случае при обращении к элементу он будет перемещаться в конец списка, а наименее используемые элементы будут постепенно группироваться в начале списка. Так же в стандартной реализации `LinkedHashMap` есть метод `removeEldestEntries()`, который возвращает `true`, если текущий объект `LinkedHashMap` должен удалить наименее используемый элемент из коллекции при использовании методов `put()` и `putAll()`.
|
||||
|
||||
```java
|
||||
public class LRUCache<K, V> extends LinkedHashMap<K, V> {
|
||||
private static final int MAX_ENTRIES = 10;
|
||||
|
||||
public LRUCache(int initialCapacity) {
|
||||
super(initialCapacity, 0.85f, true);
|
||||
}
|
||||
|
||||
@Override
|
||||
protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {
|
||||
return size() > MAX_ENTRIES;
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
Стоит заметить, что `LinkedHashMap` не позволяет полностью реализовать LRU-алгоритм, поскольку при вставке уже имеющегося в коллекции элемента порядок итерации по элементам не меняется.
|
||||
|
||||
[к оглавлению](#java-collections-framework)
|
||||
|
||||
##Как одной строчкой скопировать элементы любой `collection` в массив?
|
||||
```java
|
||||
Object[] array = collection.toArray();
|
||||
```
|
||||
|
||||
[к оглавлению](#java-collections-framework)
|
||||
|
||||
##Как одним вызовом из `List` получить `List` со всеми элементами, кроме первых и последних 3-х?
|
||||
```java
|
||||
List<Integer> subList = list.subList(3, list.size() - 3);
|
||||
```
|
||||
|
||||
[к оглавлению](#java-collections-framework)
|
||||
|
||||
##Как одной строчкой преобразовать `HashSet` в `ArrayList`?
|
||||
```java
|
||||
ArrayList<Integer> list = new ArrayList<>(new HashSet<>());
|
||||
```
|
||||
|
||||
[к оглавлению](#java-collections-framework)
|
||||
|
||||
##Как одной строчкой преобразовать `ArrayList` в `HashSet`?
|
||||
```java
|
||||
HashSet<Integer> set = new HashSet<>(new ArrayList<>());
|
||||
```
|
||||
|
||||
[к оглавлению](#java-collections-framework)
|
||||
|
||||
##Сделайте `HashSet` из ключей `HashMap`.
|
||||
```java
|
||||
HashSet<Object> set = new HashSet<>(map.keySet());
|
||||
```
|
||||
|
||||
[к оглавлению](#java-collections-framework)
|
||||
|
||||
##Сделайте `HashMap` из `HashSet<Map.Entry<K, V>>`.
|
||||
```java
|
||||
HashMap<K, V> map = new HashMap<>(set.size());
|
||||
for (Map.Entry<K, V> entry : set) {
|
||||
map.put(entry.getKey(), entry.getValue());
|
||||
}
|
||||
```
|
||||
|
||||
[к оглавлению](#java-collections-framework)
|
||||
|
||||
#Источник
|
||||
+ [parshinpn.pro](http://www.parshinpn.pro/content/voprosy-i-otvety-na-sobesedovanii-po-teme-java-collection-framework-chast-1)
|
||||
+ [Хабрахабр](https://habrahabr.ru/post/162017/)
|
||||
+ [Quizful](http://www.quizful.net/interview/java)
|
||||
+ [JavaRush](http://info.javarush.ru/)
|
||||
+ [Хабрахабр:Справочник по Java Collections Framework](https://habrahabr.ru/post/237043/)
|
||||
|
|
@ -0,0 +1,277 @@
|
|||
[Вопросы для собеседования на Java Junior](README.md)
|
||||
|
||||
#JDBC
|
||||
+ [Что такое _JDBC_?](#Что-такое-jdbc)
|
||||
+ [В чем заключаются преимущества использования JDBC?](#В-чем-заключаются-преимущества-использования-jdbc)
|
||||
+ [Что из себя представляет JDBC URL?](#Что-из-себя-представляет-jdbc-url)
|
||||
+ [Из каких частей стоит JDBC?](#Из-каких-частей-стоит-jdbc)
|
||||
+ [Перечислите основные типы данных используемые в JDBC. Как они связаны с типами Java?](#Перечислите-основные-классы-и-интерфейсы-jdbc)
|
||||
+ [Опишите основные этапы работы с базой данных с использованием JDBC.](#Опишите-основные-этапы-работы-с-базой-данных-при-использовании-jdbc)
|
||||
+ [Как зарегистрировать драйвер JDBC?](#Как-зарегистрировать-драйвер-jdbc)
|
||||
+ [Как установить соединение с базой данных?](#Как-установить-соединение-с-базой-данных)
|
||||
+ [Какие уровни изоляции транзакций поддерживаются в JDBC?](#Какие-уровни-изоляции-транзакций-поддерживаются-в-jdbc)
|
||||
+ [При помощи чего формируются запросы к базе данных?](#При-помощи-чего-формируются-запросы-к-базе-данных)
|
||||
+ [Чем отличается Statement от PreparedStatement?](#Чем-отличается-statement-от-preparedstatement)
|
||||
+ [Как осуществляется запрос к базе данных и обработка результатов?](#Как-осуществляется-запрос-к-базе-данных-и-обработка-результатов)
|
||||
+ [Как вызвать хранимую процедуру?](#Как-вызвать-хранимую-процедуру)
|
||||
+ [Как закрыть соединение с базой данных?](#Как-закрыть-соединение-с-базой-данных)
|
||||
|
||||
##Что такое _JDBC_?
|
||||
__JDBC, Java DataBase Connectivity (соединение с базами данных на Java)__ — промышленный стандарт взаимодействия Java-приложений с различными СУБД. Реализован в виде пакета `java.sql`, входящего в состав Java SE.
|
||||
|
||||
JDBC основан на концепции драйверов, которые позволяют получать соединение с базой данных по специально описанному URL. При загрузке драйвер регистрирует себя в системе и в дальнейшем автоматически вызывается, когда программа требует URL, содержащий протокол, за который этот драйвер отвечает.
|
||||
|
||||
[к оглавлению](#jdbc)
|
||||
|
||||
##В чем заключаются преимущества использования JDBC?
|
||||
Преимуществами JDBC считают:
|
||||
|
||||
+ Лёгкость разработки: разработчик может не знать специфики базы данных, с которой работает;
|
||||
+ Код практически не меняется, если компания переходит на другую базу данных (количество изменений зависит исключительно от различий между диалектами SQL);
|
||||
+ Не нужно дополнительно устанавливать клиентскую программу;
|
||||
+ К любой базе данных можно подсоединиться через легко описываемый URL.
|
||||
|
||||
[к оглавлению](#jdbc)
|
||||
|
||||
##Что из себя представляет JDBC URL?
|
||||
__JDBC URL__ состоит из:
|
||||
|
||||
+ `<protocol>:` (протокола) - всегда `jdbc:`.
|
||||
+ `<subprotocol>:` (подпротокола) - это имя драйвера или имя механизма соединения с базой данных. Подпротокол может поддерживаться одним или несколькими драйверами. Лежащий на поверхности пример подпротокола - это "odbc", отведенный для URL, обозначающих имя источника данных ODBC. В случае необходимости использовать сервис имен (т.е. имя базы данных в JDBC URL не будет действительным именем базы данных), то подпротоколом может выступать сервис имен.
|
||||
+ `<subname>` (подимени) - это идентификатор базы данных. Значение подимени может менятся в зависимости от подпротокола, и может также иметь под-подимя с синтаксисом, определяемым разработчиком драйвера. Назначение подимени - это предоставление всей информации, необходимой для поиска базы данных. Например, если база данных находится в Интернет, то в состав подимени JDBC URL должен быть включен сетевой адрес, подчиняющийся следующим соглашениям: `//<hostname>:<port>/<subsubname`.
|
||||
|
||||
Пример JDBC URL для подключения к MySQL базе данных «Test» расположенной по адресу localhost и ожидающей соединений по порту 3306: `jdbc:mysql://localhost:3306/Test`
|
||||
|
||||
[к оглавлению](#jdbc)
|
||||
|
||||
##Из каких частей стоит JDBC?
|
||||
JDBC состоит из двух частей:
|
||||
|
||||
+ __JDBC API__, который содержит набор классов и интерфейсов, определяющих доступ к базам данных. Эти классы и методы объявлены в двух пакетах - `java.sql` и `javax.sql`;
|
||||
+ __JDBC-драйвер__, компонент, специфичный для каждой базы данных.
|
||||
|
||||
JDBC превращает вызовы уровня API в «родные» команды того или иного сервера баз данных.
|
||||
|
||||
[к оглавлению](#jdbc)
|
||||
|
||||
##Перечислите основные классы и интерфейсы JDBC.
|
||||
+ `java.sql.DriverManager` - позволяет загрузить и зарегистрировать необходимый JDBC-драйвер, а затем получить соединение с базой данных.
|
||||
|
||||
+ `javax.sql.DataSource` - решает те же задачи, что и _DriverManager_, но более удобным и универсальным образом. Существуют также `javax.sql.ConnectionPoolDataSource` и `javax.sq1.XADataSource` задача которых - обеспечение поддержки пула соединений.
|
||||
|
||||
+ `java.sql.Connection` - обеспечивает формирование запросов к источнику данных и управление транзакциями. Также предусмотрены интерфейсы `javax.sql.PooledConnection` и `javax.sql.XAConnection`.
|
||||
|
||||
+ `java.sql.Statement` , `java.sql.PreparedStatement` и `java.sql.CallableStatenient` - эти интерфейсы позволяют отправить запрос к источнику данных.
|
||||
|
||||
+ `java.sql.ResultSet` - объявляет методы, которые позволяют перемещаться по набору данных и считывать значения отдельных полей в текущей записи.
|
||||
|
||||
+ `java.sql.ResultSetMetaData` - позволяет получить информацию о структуре набора данных.
|
||||
|
||||
+ `java.sql.DatabaseMetaData` - позволяет получить информацию о структуре источника данных.
|
||||
|
||||
[к оглавлению](#jdbc)
|
||||
|
||||
##Перечислите основные типы данных используемые в JDBC. Как они связаны с типами Java?
|
||||
|
||||
| JDBC Type | Java Object Type |
|
||||
|---------------:|---------------------------|
|
||||
| __CHAR__ | `String` |
|
||||
| __VARCHAR__ | `String` |
|
||||
| __LONGVARCHAR__ | `String` |
|
||||
| __NUMERIC__ | `java.math.BigDecimal` |
|
||||
| __DECIMAL__ | `java.math.BigDecimal` |
|
||||
| __BIT__ | `Boolean` |
|
||||
| __TINYINT__ | `Integer` |
|
||||
| __SMALLINT__ | `Integer` |
|
||||
| __INTEGER__ | `Integer` |
|
||||
| __BIGINT__ | `Long` |
|
||||
| __REAL__ | `Float` |
|
||||
| __FLOAT__ | `Double` |
|
||||
| __DOUBLE__ | `Double` |
|
||||
| __BINARY__ | `byte[]` |
|
||||
| __VARBINARY__ | `byte[]` |
|
||||
| __LONGVARBINARY__ | `byte[]` |
|
||||
| __DATE__ | `java.sql.Date` |
|
||||
| __TIME__ | `java.sql.Time` |
|
||||
| __TIMESTAMP__ | `java.sql.Timestamp` |
|
||||
| __CLOB__ | `Clob` |
|
||||
| __BLOB__ | `Blob` |
|
||||
| __ARRAY__ | `Array` |
|
||||
| __STRUCT__ | `Struct`|
|
||||
| __REF__ | `Ref` |
|
||||
| __DISTINCT__ | сопоставление базового типа |
|
||||
| __JAVA_OBJECT__ | базовый класс Java |
|
||||
|
||||
[к оглавлению](#jdbc)
|
||||
|
||||
##Опишите основные этапы работы с базой данных при использовании JDBC.
|
||||
+ Регистрация драйверов;
|
||||
+ Установление соединения с базой данных;
|
||||
+ Создание запроса(ов) к базе данных;
|
||||
+ Выполнение запроса(ов) к базе данных;
|
||||
+ Обработка результата(ов);
|
||||
+ Закрытие соединения с базой данных.
|
||||
|
||||
[к оглавлению](#jdbc)
|
||||
|
||||
##Как зарегистрировать драйвер JDBC?
|
||||
Регистрацию драйвера можно осуществить несколькими способами:
|
||||
|
||||
+ `java.sql.DriverManager.registerDriver(%объект класса драйвера%)`.
|
||||
|
||||
+ `Class.forName(«полное имя класса драйвера»).newInstance()`.
|
||||
|
||||
+ `Class.forName(«полное имя класса драйвера»)`;
|
||||
|
||||
[к оглавлению](#jdbc)
|
||||
|
||||
##Как установить соединение с базой данных?
|
||||
Для установки соединения с базой данных используется статический вызов `java.sql.DriverManager.getConnection(...)` .
|
||||
|
||||
|
||||
В качестве параметра может передаваться:
|
||||
|
||||
+ URL базы данных
|
||||
```java
|
||||
static Connection getConnection(String url)
|
||||
```
|
||||
|
||||
+ URL базы данных и набор свойств для инициализации
|
||||
```java
|
||||
static Connection getConnection(String url, Properties info)
|
||||
```
|
||||
|
||||
+ URL базы данных, имя пользователя и пароль
|
||||
```java
|
||||
static Connection getConnection(String url, String user, String password)
|
||||
```
|
||||
|
||||
В результате вызова будет установлено соединение с базой данных и создан объект класса `java.sql.Connection` - своеобразная «сессия», внутри контекста которой и будет происходить дальнейшая работа с базой данных.
|
||||
|
||||
[к оглавлению](#jdbc)
|
||||
|
||||
##Какие уровни изоляции транзакций поддерживаются в JDBC?
|
||||
__Уровень изолированности транзакций__ — значение, определяющее уровень, при котором в транзакции допускаются несогласованные данные, то есть степень изолированности одной транзакции от другой. Более высокий уровень изолированности повышает точность данных, но при этом может снижаться количество параллельно выполняемых транзакций. С другой стороны, более низкий уровень изолированности позволяет выполнять больше параллельных транзакций, но снижает точность данных.
|
||||
|
||||
Во время использования транзакций, для обеспечения целостности данных, СУБД использует блокировки, чтобы заблокировать доступ других обращений к данным, участвующим в транзакции. Такие блокировки необходимы, чтобы предотвратить:
|
||||
|
||||
+ _«грязное» чтение (dirty read)_ — чтение данных, добавленных или изменённых транзакцией, которая впоследствии не подтвердится (откатится);
|
||||
|
||||
+ _неповторяющееся чтение (non-repeatable read)_ — при повторном чтении в рамках одной транзакции ранее прочитанные данные оказываются изменёнными;
|
||||
|
||||
+ _фантомное чтение (phantom reads)_ — ситуация, когда при повторном чтении в рамках одной транзакции одна и та же выборка дает разные множества строк.
|
||||
|
||||
Уровни изоляции транзакций определены в виде констант интерфейса `java.sql.Connection`:
|
||||
+ `TRANSACTION_NONE` – драйвер не поддерживает транзакции;
|
||||
|
||||
+ `TRANSACTION_READ_UNCOMMITTED` – позволяет транзакциям видеть несохраненные изменения данных: разрешает грязное, непроверяющееся и фантомное чтения;
+ `TRANSACTION_READ_COMMITTED` – любое изменение, сделанное в транзакции, не видно вне неё, пока она не сохранена: предотвращает грязное чтение, но разрешает непроверяющееся и фантомное;
|
||||
|
||||
+ `TRANSACTION_REPEATABLE_READ` – запрещает грязное и непроверяющееся, фантомное чтение разрешено;
+ `TRANSACTION_SERIALIZABLE` – грязное, непроверяющееся и фантомное чтения запрещены.
|
||||
|
||||
> __NB!__ Сервер базы данных может не поддерживать все уровни изоляции. Интерфейс `java.sql.DatabaseMetaData` предоставляет информацию об уровнях изолированности транзакций, которые поддерживаются данной СУБД.
|
||||
|
||||
Уровень изоляции транзакции используемый СУБД можно задать с помощью метода `setTransactionIsolation()` объекта `java.sql.Connection`. Получить информацию о применяемом уровне изоляции поможет метод `getTransactionIsolation()`.
|
||||
|
||||
[к оглавлению](#jdbc)
|
||||
|
||||
##При помощи чего формируются запросы к базе данных?
|
||||
|
||||
Для выполнения запросов к базе данных в Java используются три интерфейса:
|
||||
|
||||
+ `java.sql.Statement` - для операторов SQL без параметров;
|
||||
+ `java.sql.PreparedStatement` - для операторов SQL с параметрами и часто выполняемых операторов;
|
||||
+ `java.sql.CallableStatement` - для исполнения хранимых в базе процедур.
|
||||
|
||||
Объекты-носители интерфейсов создаются при помощи методов объекта `java.sql.Connection`:
|
||||
|
||||
+ `java.sql.createStatement()` возвращает объект _Statement_;
|
||||
+ `java.sql.prepareStatement()` возвращает объект _PreparedStatement_;
|
||||
+ `java.sql.prepareCall()` возвращает объект _CallableStatement_;
|
||||
|
||||
[к оглавлению](#jdbc)
|
||||
|
||||
##Чем отличается Statement от PreparedStatement?
|
||||
+ __Statement__: используется для простых случаев запроса без параметров.
|
||||
+ __PreparedStatement__: предварительно компилирует запрос, который может содержать входные параметры и выполняться несколько раз с разным набором этих параметров.
|
||||
|
||||
Перед выполнением СУБД разбирает каждый запрос, оптимизирует его и создает «план» (query plan) его выполнения. Если один и тот же запрос выполняется несколько раз, то СУБД в состоянии кэшировать план его выполнения и не производить этапов разборки и оптимизации повторно. Благодаря этому запрос выполняется быстрее.
|
||||
|
||||
Суммируя: _PreparedStatement_ выгодно отличается от _Statement_ тем, что при повторном использовании с одним или несколькими наборами параметров позволяет получить преимущества заранее прекомпилированного и кэшированного запроса, помогая при этом избежать SQL Injection.
|
||||
|
||||
[к оглавлению](#jdbc)
|
||||
|
||||
##Как осуществляется запрос к базе данных и обработка результатов?
|
||||
Выполнение запросов осуществляется при помощи вызова методов объекта, реализующего интерфейс `java.sql.Statement`:
|
||||
|
||||
+ __`executeQuery()`__ - для запросов, результатом которых является один набор значений, например запросов `SELECT`. Результатом выполнения является объект класса `java.sql.ResultSet`;
|
||||
|
||||
+ __`executeUpdate()`__ - для выполнения операторов `INSERT`, `UPDATE` или `DELETE`, а также для операторов _DDL (Data Definition Language)_. Метод возвращает целое число, показывающее, сколько записей было модифицировано;
|
||||
|
||||
+ __`execute()`__ – исполняет SQL-команды, которые могут возвращать различные результаты. Например, может использоваться для операции `CREATE TABLE`. Возвращает `true`, если первый результат содержит _ResultSet_ и `false`, если первый результат - это количество модифицированных записей или результат отсутствует. Чтобы получить первый результат необходимо вызвать метод `getResultSet()` или `getUpdateCount()`. Остальные результаты доступны через вызов `getMoreResults()`, который при необходимости может быть произведён многократно.
|
||||
|
||||
Объект с интерфейсом `java.sql.ResultSet` хранит в себе результат запроса к базе данных - некий набор данных, внутри которого есть курсор, указывающий на один из элементов набора данных - текущую запись.
|
||||
|
||||
Используя курсор можно перемещаться по набору данных при помощи метода `next()`.
|
||||
|
||||
> __NB!__ Сразу после получения набора данных его курсор находится перед первой записью и чтобы сделать её текущей необходимо вызвать метод `next()`.
|
||||
|
||||
Содержание полей текущей записи доступно через вызовы методов `getInt()`, `getFloat()`, `getString()`, `getDate()` и им подобных.
|
||||
|
||||
[к оглавлению](#jdbc)
|
||||
|
||||
##Как вызвать хранимую процедуру?
|
||||
__Хранимые процедуры__ – это именованный набор операторов SQL хранящийся на сервере. Такую процедуру можно вызвать из Java-класса с помощью вызова методов объекта реализующего интерфейс `java.sql.Statement`.
|
||||
|
||||
Выбор объекта зависит от характеристик хранимой процедуры:
|
||||
|
||||
+ без параметров → `Statement`
|
||||
+ с входными параметрами → `PreparedStatement`
|
||||
+ с входными и выходными параметрами → `CallableStatement`
|
||||
|
||||
> Если неизвестно, как была определена хранимая процедура, для получения информации о хранимой процедуре (например, имен и типов параметров) можно использовать методы `java.sql.DatabaseMetaData` позволяющие получить информацию о структуре источника данных.
|
||||
|
||||
Пример вызова хранимой процедуры с входными и выходными параметрами:
|
||||
|
||||
```java
|
||||
public vois runStoredProcedure(final Connection connection) throws Exception {
|
||||
// описываем хранимую процедуру
|
||||
String procedure = "{ call procedureExample(?, ?, ?) }";
|
||||
|
||||
// подготавливаем запрос
|
||||
CallableStatement cs = connection.prepareCall(procedure);
|
||||
|
||||
// устанавливаем входные параметры
|
||||
cs.setString(1, "abcd");
|
||||
cs.setBoolean(2, true);
|
||||
cs.setInt(3, 10);
|
||||
|
||||
// описываем выходные параметры
|
||||
cs.registerOutParameter(1, java.sql.Types.VARCHAR);
|
||||
cs.registerOutParameter(2, java.sql.Types.INTEGER);
|
||||
|
||||
// запускаем выполнение хранимой процедуры
|
||||
cs.execute();
|
||||
|
||||
// получаем результаты
|
||||
String parameter1 = cs.getString(1);
|
||||
int parameter2 = cs.getInt(2);
|
||||
|
||||
// заканчиваем работу с запросом
|
||||
cs.close();
|
||||
}
|
||||
```
|
||||
|
||||
[к оглавлению](#jdbc)
|
||||
|
||||
##Как закрыть соединение с базой данных?
|
||||
Соединение с базой данной закрывается вызовом метода `close()` у соответствующего объекта `java.sql.Connection` или посредством использования механизма try-with-resources при создании такого объекта, появившегося в Java 7.
|
||||
|
||||
> __NB!__ Предварительно необходимо закрыть все запросы созданные этим соединением.
|
||||
|
||||
[к оглавлению](#jdbc)
|
||||
|
||||
#Источники
|
||||
+ [Википедия - JDBC](https://ru.wikipedia.org/wiki/Java_Database_Connectivity)
|
||||
+ [IBM developerWorks®](http://www.ibm.com/developerworks/ru/library/dm-1209storedprocedures/)
|
||||
+ [Документация к пакету java.sql](https://docs.oracle.com/javase/7/docs/api/java/sql/package-summary.html)
|
||||
+ [Википедия - Уровень изолированности транзакции](https://ru.wikipedia.org/wiki/Уровень_изолированности_транзакций)
|
||||
|
|
@ -0,0 +1,110 @@
|
|||
[Вопросы для собеседования на Java Junior](README.md)
|
||||
|
||||
##Журналирование
|
||||
+ [Какие существуют типы логов?](#Какие-существуют-типы-логов)
|
||||
+ [Из каких частей состоит система журналирования log4j?](#Из-каких-частей-состоит-система-журналирования-log4j)
|
||||
+ [Что такое _Logger_ в log4j?](#Что-такое-logger-в-log4j)
|
||||
+ [Что такое _Appender_ в log4j?](#Что-такое-appender-в-log4j)
|
||||
+ [Что такое _Layout_ в log4j?](#Что-такое-layout-в-log4j)
|
||||
+ [Перечислите уровни журналирования в log4j? Назовите порядок их приоритетности.](#Перечислите-уровни-журналирования-в-log4j-Назовите-порядок-их-приоритетности)
|
||||
+ [Какие существуют способы конфигурирования log4j?](#Какие-существуют-способы-конфигурирования-log4j)
|
||||
|
||||
###Какие существуют типы логов?
|
||||
+ системы (System);
|
||||
+ безопасности (Security);
|
||||
+ приложения (Application, Buisness).
|
||||
|
||||
> Пользователь входит в приложение, проверяется пароль. Это действие относится к безопасности (Security). Дальше он запускает какой-нибудь модуль. Это событие уровня приложения (Application). Модуль при старте обращается к другому модулю за какими-то дополнительными данными, производит какие-либо еще вызовы – это уже системные действия (System).
|
||||
|
||||
[к оглавлению](#Журналирование)
|
||||
|
||||
###Из каких частей состоит система журналирования log4j?
|
||||
Система журналирования состоит из трёх основных частей:
|
||||
|
||||
+ управляющей журналированием - __logger__;
|
||||
+ добавляющей в журнал - __appender__;
|
||||
+ определяющей формат добавления - __layout__.
|
||||
|
||||
[к оглавлению](#Журналирование)
|
||||
|
||||
###Что такое _Logger_ в log4j?
|
||||
__Logger__ представляет собой объект класса `org.apache.log4j.Logger`, который используется как управляющий интерфейс для журналирования сообщений с возможностью задавать уровень детализации. Именно logger проверяет нужно ли обрабатывать сообщение и если журналирование необходимо, то сообщение передаётся в appender, если нет - система завершает обработку данного сообщения.
|
||||
|
||||
[к оглавлению](#Журналирование)
|
||||
|
||||
###Что такое _Appender_ в log4j?
|
||||
__Appender__ - это именованный объект журнала событий, реализующий интерфейс `org.apache.log4j.Appender` и добавляющий события в журнал. Appender вызывает разные вспомогательные инструменты - компоновщик, фильтр, обработчик ошибок (если они определены и необходимы). В ходе этой работы окончательно устанавливается необходимость записи сообщения, сообщению придаются окончательные содержание и форма.
|
||||
|
||||
В log4j журнал может представлять:
|
||||
|
||||
+ консоль;
|
||||
+ файл;
|
||||
+ сокет;
|
||||
+ объект класса реализующего `java.io.Writer` или `java.io.OutputStream`;
|
||||
+ JDBC хранилище;
|
||||
+ тему (topic) JMS;
|
||||
+ NT Event Log;
|
||||
+ SMTP;
|
||||
+ Syslog;
|
||||
+ Telnet.
|
||||
|
||||
Наиболее часто используемые log4j appender-ы:
|
||||
|
||||
+ `org.apache.log4j.ConsoleAppender` - вывод в консоль;
|
||||
+ `org.apache.log4j.FileAppender` - добавление в файл;
|
||||
+ `org.apache.log4j.DailyRollingFileAppender` - добавление в файл с обновлением файла через заданный промежуток времени;
|
||||
+ `org.apache.log4j.RollingFileAppender` - добавление в файл с обновлением файла по достижению определенного размера;
|
||||
+ `org.apache.log4j.varia.ExternallyRolledFileAppender` - расширение _RollingFileAppender_ обновляющее файл по команде принятой с заданного порта;
|
||||
+ `org.apache.log4j.net.SMTPAppender` - сообщение по SMTP;
|
||||
+ `org.apache.log4j.AsyncAppender` - позволяет, используя отдельный поток, организовать асинхронную работу, когда сообщения фиксируются лишь при достижении определенного уровня заполненности промежуточного буфера.
|
||||
+ `org.apache.log4j.nt.NTEventLogAppender` - добавление в NT Event Log;
|
||||
+ `org.apache.log4j.net.SyslogAppender` - добавление в Syslog;
|
||||
+ `org.apache.log4j.jdbc.JDBCAppender` - запись в хранилище JDBC;
|
||||
+ `org.apache.log4j.lf5.LF5Appender` - сообщение передаётся в специальный GUI интерфейс LogFactor5
|
||||
+ `org.apache.log4j.net.SocketAppender` - трансляция сообщения по указанному адресу и порту;
|
||||
+ `org.apache.log4j.net.SocketHubAppender` - рассылка сообщения сразу нескольким удалённым серверам соединённым по заданному порту;
|
||||
+ `org.apache.log4j.net.TelnetAppender` - отсылка сообщения по протоколу Telenet;
|
||||
+ `org.apache.log4j.net.JMSAppender` - добавление сообщения в JMS.
|
||||
|
||||
[к оглавлению](#Журналирование)
|
||||
|
||||
###Что такое _Layout_ в log4j?
|
||||
__Layout__ - наследник класса `org.apache.log4j.Layout` предоставляющий возможность форматирования сообщения перед добавлением в журнал.
|
||||
|
||||
В log4j существуют следующие типы layout-ов:
|
||||
|
||||
+ `org.apache.log4j.SimpleLayout` - на выходе получается строка содержащая лишь уровень вывода и сообщение;
|
||||
+ `org.apache.log4j.HTMLLayout` - форматирует сообщение в виде элемента HTML-таблицы;
|
||||
+ `org.apache.log4j.xml.XMLLayout` - компанует сообщение в виде XML формате;
|
||||
+ `org.apache.log4j.TTCCLayout` - на выходе сообщение дополняется информацией о времени, потоке, имени логгера и вложенном диагностическом контексте;
|
||||
+ `org.apache.log4j.PatternLayout` / `org.apache.log4j.EnhancedPatternLayout` - настройка форматирования сообщения при помощи шаблона заданного пользователем.
|
||||
|
||||
[к оглавлению](#Журналирование)
|
||||
|
||||
###Перечислите уровни журналирования в log4j? Назовите порядок их приоритетности.
|
||||
+ __OFF__ - отсутствие журналирования;
|
||||
+ __FATAL__ - фатальная ошибка;
|
||||
+ __ERROR__ - ошибка;
|
||||
+ __WARN__ - предупреждение;
|
||||
+ __INFO__ - информация;
|
||||
+ __DEBUG__ - детальная информация для отладки;
|
||||
+ __TRACE__ – трассировка всех сообщений.
|
||||
|
||||
Между уровнями логирования установлен следующий порядок приоритетов:
|
||||
|
||||
`OFF < TRACE < DEBUG < INFO < WARN < ERROR < FATAL < ALL`
|
||||
|
||||
[к оглавлению](#Журналирование)
|
||||
|
||||
###Какие существуют способы конфигурирования log4j?
|
||||
Для того, чтобы log4j начал работать нужно предоставить ему конфигурацию. Это можно сделать несколькими путями:
|
||||
|
||||
+ Создать конфигурацию программно, т.е. получить logger, определить уровень журналирования, прикрепить appender и задать способ форматирования.
|
||||
+ Указать файл или URL как аргумент при запуске java-машины `-Dlog4j.configuration=путь/к/файлу/конфигурации`, а затем прочитать его в программе при помощи `PropertyConfigurator.configure(...)`/ `DOMConfigurator.configure(...)` для формата `.properties` или `XML` соответственно.
|
||||
+ Загрузить конфигурацию из файла в формате `XML` или `.properties`: log4j ищет файл конфигурации в classpath. Сначала ищется файл `log4j.xml` и, если таковой не найден, - файл `log4j.properties`.
|
||||
|
||||
[к оглавлению](#Журналирование)
|
||||
|
||||
##Источники
|
||||
+ [Quizful](http://www.quizful.net/)
|
||||
+ [Skipy](http://skipy.ru/useful/logging.html#log4j_concepts_logger)
|
||||
|
|
@ -0,0 +1,168 @@
|
|||
[Вопросы для собеседования на Java Junior](README.md)
|
||||
|
||||
#ООП
|
||||
+ [Что такое _ООП_?](#Что-такое-ООП)
|
||||
+ [Назовите основные принципы _ООП_.](#Назовите-основные-принципы-ООП)
|
||||
+ [Что такое _«инкапсуляция»_?](#Что-такое-инкапсуляция)
|
||||
+ [Что такое _«наследование»_?](#Что-такое-наследование)
|
||||
+ [Что такое _«полиморфизм»_?](#Что-такое-полиморфизм)
|
||||
+ [Что такое _«абстракция»_?](#Что-такое-абстракция)
|
||||
+ [Что представляет собой _«обмен сообщениями»_?](#Что-представляет-собой-обмен-сообщениями)
|
||||
+ [Расскажите про основные понятия ООП: _«класс»_, _«объект»_, _«интерфейс»_.](#Расскажите-про-основные-понятия-ООП-класс-объект-интерфейс)
|
||||
+ [В чем заключаются преимущества и недостатки объектно-ориентированного подхода в программировании?](#В-чем-заключаются-преимущества-и-недостатки-объектно-ориентированного-подхода-в-программировании)
|
||||
+ [Что подразумевают в плане принципов ООП выражения _«является»_ и _«имеет»_?](#Что-подразумевают-в-плане-принципов-ООП-выражения-является-и-имеет)
|
||||
+ [В чем разница между _композицией_ и _агрегацией_?](#В-чем-разница-между-композицией-и-агрегацией)
|
||||
+ [Что такое _статическое_ и _динамическое связывание_?](#Что-такое-статическое-и-динамическое-связывание)
|
||||
|
||||
##Что такое _ООП_?
|
||||
__Объектно-ориентированное программирование (ООП)__ — методология программирования, основанная на представлении программы в виде совокупности объектов, каждый из которых является экземпляром определенного класса, а классы образуют иерархию наследования.
|
||||
|
||||
+ объектно-ориентированное программирование использует в качестве основных логических конструктивных элементов объекты, а не алгоритмы;
|
||||
+ каждый объект является экземпляром определенного класса
|
||||
+ классы образуют иерархии.
|
||||
|
||||
Программа считается объектно-ориентированной, только если выполнены все три указанных требования. В частности, программирование, не использующее наследование, называется не объектно-ориентированным, а программированием с помощью абстрактных типов данных.
|
||||
|
||||
Согласно парадигме ООП программа состоит из объектов, обменивающихся сообщениями. Объекты могут обладать состоянием, единственный способ изменить состояние объекта - послать ему сообщение, в ответ на которое, объект может изменить собственное состояние.
|
||||
|
||||
[к оглавлению](#ООП)
|
||||
|
||||
##Назовите основные принципы _ООП_.
|
||||
+ _Инкапсуляция_ - сокрытие реализации.
|
||||
+ _Наследование_ - создание новой сущности на базе уже существующей.
|
||||
+ _Полиморфизм_ - возможность иметь разные формы для одной и той же сущности.
|
||||
+ _Абстракция_ - набор общих характеристик.
|
||||
+ _Посылка сообщений_ - форма связи, взаимодействия между сущностями.
|
||||
+ _Переиспользование_- все что перечислено выше работает на повторное использование кода.
|
||||
|
||||
Это единственно верный порядок парадигм ООП, так как каждая последующая использует предыдущие.
|
||||
|
||||
[к оглавлению](#ООП)
|
||||
|
||||
##Что такое _«инкапсуляция»_?
|
||||
__Инкапсуляция__ – это свойство системы, позволяющее объединить данные и методы, работающие с ними, в классе и скрыть детали реализации от пользователя, открыв только то, что необходимо при последующем использовании.
|
||||
|
||||
Цель инкапсуляции — уйти от зависимости внешнего интерфейса класса (то, что могут использовать другие классы) от реализации. Чтобы малейшее изменение в классе не влекло за собой изменение внешнего поведения класса.
|
||||
|
||||
>Представим на минутку, что мы оказались в конце позапрошлого века, когда Генри Форд ещё не придумал конвейер, а первые попытки создать автомобиль сталкивались с критикой властей по поводу того, что эти коптящие монстры загрязняют воздух и пугают лошадей. Представим, что для управления первым паровым автомобилем необходимо было знать, как устроен паровой котёл, постоянно подбрасывать уголь, следить за температурой, уровнем воды. При этом для поворота колёс использовать два рычага, каждый из которых поворачивает одно колесо в отдельности. Думаю, можно согласиться с тем, что вождение автомобиля того времени было весьма неудобным и трудным занятием.
|
||||
|
||||
>Теперь вернёмся в сегодняшний день к современным чудесам автопрома с коробкой-автоматом. На самом деле, по сути, ничего не изменилось. Бензонасос всё так же поставляет бензин в двигатель, дифференциалы обеспечивают поворот колёс на различающиеся углы, коленвал превращает поступательное движение поршня во вращательное движение колёс. Прогресс в другом. Сейчас все эти действия скрыты от пользователя и позволяют ему крутить руль и нажимать на педаль газа, не задумываясь, что в это время происходит с инжектором, дроссельной заслонкой и распредвалом. Именно сокрытие внутренних процессов, происходящих в автомобиле, позволяет эффективно его использовать даже тем, кто не является профессионалом-автомехаником с двадцатилетним стажем. Это сокрытие в ООП носит название инкапсуляции.
|
||||
|
||||
[к оглавлению](#ООП)
|
||||
|
||||
##Что такое _«наследование»_?
|
||||
__Наследование__ – это свойство системы, позволяющее описать новый класс на основе уже существующего с частично или полностью заимствующейся функциональностью.
|
||||
|
||||
Класс, от которого производится наследование, называется _предком_, _базовым_ или _родительским_. Новый класс – _потомком_, _наследником_ или _производным_ классом.
|
||||
|
||||
>Представим себя, на минуту, инженерами автомобильного завода. Нашей задачей является разработка современного автомобиля. У нас уже есть предыдущая модель, которая отлично зарекомендовала себя в течение многолетнего использования. Всё бы хорошо, но времена и технологии меняются, а наш современный завод должен стремиться повышать удобство и комфорт выпускаемой продукции и соответствовать современным стандартам.
|
||||
|
||||
>Нам необходимо выпустить целый модельный ряд автомобилей: седан, универсал и малолитражный хэтч-бэк. Очевидно, что мы не собираемся проектировать новый автомобиль с нуля, а, взяв за основу предыдущее поколение, внесём ряд конструктивных изменений. Например, добавим гидроусилитель руля и уменьшим зазоры между крыльями и крышкой капота, поставим противотуманные фонари. Кроме того, в каждой модели будет изменена форма кузова.
|
||||
|
||||
>Очевидно, что все три модификации будут иметь большинство свойств прежней модели (старый добрый двигатель 1970 года, непробиваемая ходовая часть, зарекомендовавшая себя отличным образом на отечественных дорогах, коробку передач и т.д.). При этом каждая из моделей будет реализовать некоторую новую функциональность или конструктивную особенность. В данном случае, мы имеем дело с наследованием.
|
||||
|
||||
[к оглавлению](#ООП)
|
||||
|
||||
##Что такое _«полиморфизм»_?
|
||||
__Полиморфизм__ – это свойство системы использовать объекты с одинаковым интерфейсом без информации о типе и внутренней структуре объекта.
|
||||
|
||||
Преимуществом полиморфизма является то, что он помогает снижать сложность программ, разрешая использование одного и того же интерфейса для задания единого набора действий. Выбор же конкретного действия, в зависимости от ситуации, возлагается на компилятор языка программирования. Отсюда следует ключевая особенность полиморфизма - использование объекта производного класса, вместо объекта базового (потомки могут изменять родительское поведение, даже если обращение к ним будет производиться по ссылке родительского типа).
|
||||
|
||||
>Любое обучение вождению не имело бы смысла, если бы человек, научившийся водить, скажем, ВАЗ 2106 не мог потом водить ВАЗ 2110 или BMW X3. С другой стороны, трудно представить человека, который смог бы нормально управлять автомобилем, в котором педаль газа находится левее педали тормоза, а вместо руля – джойстик.
|
||||
|
||||
>Всё дело в том, что основные элементы управления автомобиля имеют одну и ту же конструкцию и принцип действия. Водитель точно знает, что для того, чтобы повернуть налево, он должен повернуть руль, независимо от того, есть там гидроусилитель или нет.
|
||||
Если человеку надо доехать с работы до дома, то он сядет за руль автомобиля и будет выполнять одни и те же действия, независимо от того, какой именно тип автомобиля он использует. По сути, можно сказать, что все автомобили имеют один и тот же интерфейс, а водитель, абстрагируясь от сущности автомобиля, работает именно с этим интерфейсом. Если водителю предстоит ехать по немецкому автобану, он, вероятно выберет быстрый автомобиль с низкой посадкой, а если предстоит возвращаться из отдалённого маральника в Горном Алтае после дождя, скорее всего, будет выбран УАЗ с армейскими мостами. Но, независимо от того, каким образом будет реализовываться движение и внутреннее функционирование машины, интерфейс останется прежним.
|
||||
|
||||
_Полиморфная переменная_, это переменная, которая может принимать значения разных типов, а _полиморфная функция_, это функция у которой хотя бы один аргумент является полиморфной переменной.
|
||||
Выделяют два вида полиморфных функций:
|
||||
|
||||
+ _ad hoc_, функция ведет себя по разному для разных типов аргументов (например, функция `draw()` — рисует по разному фигуры разных типов);
|
||||
+ _параметрический_, функция ведет себя одинаково для аргументов разных типов (например, функция `add()` — одинаково кладет в контейнер элементы разных типов).
|
||||
|
||||
[к оглавлению](#ООП)
|
||||
|
||||
##Что такое _«абстракция»_?
|
||||
_Абстрагирование_ – это способ выделить набор общих характеристик объекта, исключая из рассмотрения частные и незначимые. Соответственно, __абстракция__ – это набор всех таких характеристик.
|
||||
|
||||
>Представьте, что водитель едет в автомобиле по оживлённому участку движения. Понятно, что в этот момент он не будет задумываться о химическом составе краски автомобиля, особенностях взаимодействия шестерёнок в коробке передач или влияния формы кузова на скорость (разве что, автомобиль стоит в глухой пробке и водителю абсолютно нечем заняться). Однако, руль, педали, указатель поворота он будет использовать регулярно.
|
||||
|
||||
[к оглавлению](#ООП)
|
||||
|
||||
##Что представляет собой _«обмен сообщениями»_?
|
||||
Объекты взаимодействуют, посылая и получая сообщения. Сообщение — это запрос на выполнение действия, дополненный набором аргументов, которые могут понадобиться при выполнении действия. В ООП посылка сообщения (вызов метода) — это единственный путь передать управление объекту. Если объект должен «отвечать» на это сообщение, то у него должна иметься соответствующий данному сообщению метод. Так же объекты, используя свои методы, могут и сами посылать сообщения другим объектам. Обмен сообщениями реализуется с помощью динамических вызовов, что приводит к чрезвычайно позднему связыванию (extreme late binding).
|
||||
|
||||
>Пусть требуется создать физическую модель, описывающую сталкивающиеся шары разных размеров. Традиционный подход к решению этой задачи примерно таков: определяется набор данных, описывающих каждый шар (например, его координаты, массу и ускорение); каждому шару присваивается уникальный идентификатор (например, организуется массив, значение индекса которого соответствует номеру шара), который позволит отличать каждый из шаров от всех других. Наконец, пишется подпрограмма с названием, скажем, `bounce`; эта процедура должна на основе номера шара и его начальных параметров соответствующим образом изменять данные, описывающие шар. В отличие от традиционного подхода объектно-ориентированная версия программы моделирует каждый из шаров посредством объекта. При этом объект, соответствующий конкретному шару, содержит не только его параметры, но и весь код, описывающий поведение шара при различных взаимодействиях. Так, каждый шар будет иметь собственный метод `bounce()`. Вместо того, чтобы вызывать подпрограмму `bounce` с аргументом, определяющим, скажем, шар №3, необходимо будет передать объекту «шар №3» сообщение, предписывающее ему выполнить столкновение.
|
||||
|
||||
[к оглавлению](#ООП)
|
||||
|
||||
##Расскажите про основные понятия ООП: _«класс»_, _«объект»_, _«интерфейс»_.
|
||||
__Класс__ – это способ описания сущности, определяющий состояние и поведение, зависящее от этого состояния, а также правила для взаимодействия с данной сущностью (контракт).
|
||||
|
||||
С точки зрения программирования класс можно рассматривать как набор данных (полей, атрибутов, членов класса) и функций для работы с ними (методов).
|
||||
|
||||
С точки зрения структуры программы, класс является сложным типом данных.
|
||||
|
||||
__Объект (экземпляр)__ – это отдельный представитель класса, имеющий конкретное состояние и поведение, полностью определяемое классом. Каждый объект имеет конкретные значения атрибутов и методы, работающие с этими значениями на основе правил, заданных в классе.
|
||||
|
||||
__Интерфейс__ – это набор методов класса, доступных для использования. Интерфейсом класса будет являться набор всех его публичных методов в совокупности с набором публичных атрибутов. По сути, интерфейс специфицирует класс, чётко определяя все возможные действия над ним.
|
||||
|
||||
[к оглавлению](#ООП)
|
||||
|
||||
##В чем заключаются преимущества и недостатки объектно-ориентированного подхода в программировании?
|
||||
Преимущества:
|
||||
|
||||
+ Объектная модель вполне естественна, поскольку в первую очередь ориентирована на человеческое восприятие мира, а не на компьютерную реализацию.
|
||||
+ Классы позволяют проводить конструирование из полезных компонентов, обладающих простыми инструментами, что позволяет абстрагироваться от деталей реализации.
|
||||
+ Данные и операции над ними образуют определенную сущность, и они не разносятся по всей программе, как нередко бывает в случае процедурного программирования, а описываются вместе. Локализация кода и данных улучшает наглядность и удобство сопровождения программного обеспечения.
|
||||
+ Инкапсуляция позволяет привнести свойство модульности, что облегчает распараллеливание выполнения задачи между несколькими исполнителями и обновление версий отдельных компонентов.
|
||||
+ Возможность создавать расширяемые системы.
|
||||
+ Использование полиморфизма оказывается полезным при:
|
||||
+ Обработке разнородных структур данных. Программы могут работать, не различая вида объектов, что существенно упрощает код. Новые виды могут быть добавлены в любой момент.
|
||||
+ Изменении поведения во время исполнения. На этапе исполнения один объект может быть заменен другим, что позволяет легко, без изменения кода, адаптировать алгоритм в зависимости + от того, какой используется объект.
|
||||
+ Реализации работы с наследниками. Алгоритмы можно обобщить настолько, что они уже смогут работать более чем с одним видом объектов.
|
||||
+ Возможности описать независимые от приложения части предметной области в виде набора универсальных классов, или фреймворка, который в дальнейшем будет расширен за счет добавления частей, специфичных для конкретного приложения.
|
||||
+ Повторное использование кода:
|
||||
+ Сокращается время на разработку, которое может быть отдано другим задачам.
|
||||
+ Компоненты многоразового использования обычно содержат гораздо меньше ошибок, чем вновь разработанные, ведь они уже не раз подвергались проверке.
|
||||
+ Когда некий компонент используется сразу несколькими клиентами, улучшения, вносимые в его код, одновременно оказывают положительное влияние и на множество работающих с ним программ.
|
||||
+ Если программа опирается на стандартные компоненты, ее структура и пользовательский интерфейс становятся более унифицированными, что облегчает ее понимание и упрощает использование.
|
||||
|
||||
Недостатки:
|
||||
|
||||
+ В сложных иерархиях классов поля и методы обычно наследуются с разных уровней. И не всегда легко определить, какие поля и методы фактически относятся к данному классу.
|
||||
+ Код для обработки сообщения иногда «размазан» по многим методам (иначе говоря, обработка сообщения требует не одного, а многих методов, которые могут быть описаны в разных классах).
|
||||
+ Документирование классов - задача более трудная, чем это было в случае процедур и модулей. Поскольку любой метод может быть переопределен, в документации должно говориться не только о том, что делает данный метод, но и о том, в каком контексте он вызывается.
|
||||
+ Неэффективность и неэкономное распределения памяти на этапе выполнения (по причине издержек на динамическое связывание и проверки типов на этапе выполнения).
|
||||
+ Излишняя универсальность. Часто содержится больше методов, чем это реально необходимо текущей программе. А поскольку лишние методы не могут быть удалены, они становятся мертвым грузом.
|
||||
|
||||
[к оглавлению](#ООП)
|
||||
|
||||
##Что подразумевают в плане принципов ООП выражения _«является»_ и _«имеет»_?
|
||||
__«является»__ подразумевает наследование.
|
||||
__«имеет»__ подразумевает ассоциацию (агрегацию или композицию).
|
||||
|
||||
[к оглавлению](#ООП)
|
||||
|
||||
##В чем разница между _композицией_ и _агрегацией_?
|
||||
Ассоциация обозначает связь между объектами. Композиция и агрегация — частные случаи ассоциации «часть-целое».
|
||||
|
||||
Агрегация предполагает, что объекты связаны взаимоотношением «part-of» (часть). Композиция более строгий вариант агрегации. Дополнительно к требованию «part-of» накладывается условие, что экземпляр «части» может входить только в одно целое (или никуда не входить), в то время как в случае агрегации экземпляр «части» может входить в несколько целых.
|
||||
|
||||
>Например, книга состоит из страниц и мы не можем вырвать страницу из книги и вложить в другую книгу. Страницы четко привязаны к конкретной книге, поэтому это композиция.
|
||||
В тоже время мы можем взять и перенести книгу из одной библиотеки в другую - это уже агрегация.
|
||||
|
||||
[к оглавлению](#ООП)
|
||||
|
||||
##Что такое _статическое_ и _динамическое связывание_?
|
||||
Присоединение вызова метода к телу метода называется связыванием. Если связывание проводится компилятором (компоновщиком) перед запуском программы, то оно называется _статическим_ или _ранним связыванием (early binding)_.
|
||||
|
||||
В свою очередь, _позднее связывание (late binding)_ это связывание, проводимое непосредственно во время выполнения программы, в зависимости от типа объекта. Позднее связывание также называют _динамическим (dynamic)_ или _связыванием на стадии выполнения (runtime binding)_. В языках, реализующих позднее связывание, должен существовать механизм определения фактического типа объекта во время работы программы, для вызова подходящего метода. Иначе говоря, компилятор не знает тип объекта, но механизм вызова методов определяет его и вызывает соответствующее тело метода. Механизм позднего связывания зависит от конкретного языка, но нетрудно предположить, что для его реализации в объекты должна включаться какая-то дополнительная информация.
|
||||
|
||||
Для всех методов Java используется механизм позднего (динамического) связывания, если только метод не был объявлен как `final` (приватные методы являются `final` по умолчанию).
|
||||
|
||||
[к оглавлению](#ООП)
|
||||
|
||||
#Источники
|
||||
+ [DevColibri](http://devcolibri.com/720)
|
||||
+ [Хабрахабр](https://habrahabr.ru/post/87119/)
|
||||
+ [Википедия](https://ru.wikipedia.org/wiki/Объектно-ориентированное_программирование)
|
||||
|
|
@ -0,0 +1,148 @@
|
|||
[Вопросы для собеседования на Java Junior](README.md)
|
||||
|
||||
# Шаблоны проектирования
|
||||
+ [Что такое _«шаблон проектирования»_?](#Что-такое-шаблон-проектирования)
|
||||
+ [Назовите основные характеристики шаблонов.](#Назовите-основные-характеристики-шаблонов)
|
||||
+ [Типы шаблонов проектирования.](#Типы-шаблонов-проектирования)
|
||||
+ [Приведите примеры основных шаблонов проектирования.](#Приведите-примеры-основных-шаблонов-проектирования)
|
||||
+ [Приведите примеры порождающих шаблонов проектирования.](#Приведите-примеры-порождающих-шаблонов-проектирования)
|
||||
+ [Приведите примеры структурных шаблонов проектирования.](#Приведите-примеры-структурных-шаблонов-проектирования)
|
||||
+ [Приведите примеры поведенческих шаблонов проектирования.](#Приведите-примеры-поведенческих-шаблонов-проектирования)
|
||||
+ [Что такое _«антипаттерн»_? Какие антипаттерны вы знаете?](#Что-такое-антипаттерн-Какие-антипаттерны-вы-знаете)
|
||||
+ [Что такое _Dependency Injection_?](#Что-такое-dependency-injection)
|
||||
|
||||
## Что такое _«шаблон проектирования»_?
|
||||
__Шаблон (паттерн) проектирования (design pattern)__ — это проверенное и готовое к использованию решение. Это не класс и не библиотека, которую можно подключить к проекту, это нечто большее - он не зависит от языка программирования, не является законченным образцом, который может быть прямо преобразован в код и может быть реализован по разному в разных языках программирования.
|
||||
|
||||
Плюсы использования шаблонов:
|
||||
+ снижение сложности разработки за счёт готовых абстракций для решения целого класса проблем.
|
||||
+ облегчение коммуникации между разработчиками, позволяя ссылаться на известные шаблоны.
|
||||
+ унификация деталей решений: модулей и элементов проекта.
|
||||
+ возможность отыскав удачное решение, пользоваться им снова и снова.
|
||||
+ помощь в выборе выбрать наиболее подходящего варианта проектирования.
|
||||
|
||||
Минусы:
|
||||
+ слепое следование некоторому выбранному шаблону может привести к усложнению программы.
|
||||
+ желание попробовать некоторый шаблон в деле без особых на то оснований.
|
||||
|
||||
[к оглавлению](#Шаблоны-проектирования)
|
||||
|
||||
## Назовите основные характеристики шаблонов.
|
||||
+ __Имя__ - все шаблоны имеют уникальное имя, служащее для их идентификации;
|
||||
+ __Назначение__ назначение данного шаблона;
|
||||
+ __Задача__ - задача, которую шаблон позволяет решить;
|
||||
+ __Способ решения__ - способ, предлагаемый в шаблоне для решения задачи в том контексте, где этот шаблон был найден;
|
||||
+ __Участники__ - сущности, принимающие участие в решении задачи;
|
||||
+ __Следствия__ - последствия от использования шаблона как результат действий, выполняемых в шаблоне;
|
||||
+ __Реализация__ - возможный вариант реализации шаблона.
|
||||
|
||||
[к оглавлению](#Шаблоны-проектирования)
|
||||
|
||||
## Типы шаблонов проектирования.
|
||||
+ Основные (Fundamental) - основные строительные блоки других шаблонов. Большинство других шаблонов использует эти шаблоны в той или иной форме.
|
||||
+ Порождающие шаблоны (Creational) — шаблоны проектирования, которые абстрагируют процесс создание экземпляра. Они позволяют сделать систему независимой от способа создания, композиции и представления объектов. Шаблон, порождающий классы, использует наследование, чтобы изменять созданный объект, а шаблон, порождающий объекты, делегирует создание объектов другому объекту.
|
||||
+ Структурные шаблоны (Structural) определяют различные сложные структуры, которые изменяют интерфейс уже существующих объектов или его реализацию, позволяя облегчить разработку и оптимизировать программу.
|
||||
+ Поведенческие шаблоны (Behavioral) определяют взаимодействие между объектами, увеличивая таким образом его гибкость.
|
||||
|
||||
[к оглавлению](#Шаблоны-проектирования)
|
||||
|
||||
## Приведите примеры основных шаблонов проектирования.
|
||||
+ __Делегирование (Delegation pattern)__ - Сущность внешне выражает некоторое поведение, но в реальности передаёт ответственность за выполнение этого поведения связанному объекту.
|
||||
+ __Функциональный дизайн (Functional design)__ - Гарантирует, что каждая сущность имеет только одну обязанность и исполняет её с минимумом побочных эффектов на другие.
|
||||
+ __Неизменяемый интерфейс (Immutable interface)__ - Создание неизменяемого объекта.
|
||||
+ __Интерфейс (Interface)__ - Общий метод структурирования сущностей облегчающий их понимание.
|
||||
+ __Интерфейс-маркер (Marker interface)__ - В качестве атрибута (как пометки объектной сущности) применяется наличие или отсутствие реализации интерфейса-маркера. В современных языках программирования вместо этого применяются атрибуты или аннотации.
|
||||
+ __Контейнер свойств (Property container)__ - Позволяет добавлять дополнительные свойства сущности в контейнер внутри себя, вместо расширения новыми свойствами.
|
||||
+ __Канал событий (Event channel)__ - Создаёт централизованный канал для событий. Использует сущность-представитель для подписки и сущность-представитель для публикации события в канале. Представитель существует отдельно от реального издателя или подписчика. Подписчик может получать опубликованные события от более чем одной сущности, даже если он зарегистрирован только на одном канале.
|
||||
|
||||
[к оглавлению](#Шаблоны-проектирования)
|
||||
|
||||
## Приведите примеры порождающих шаблонов проектирования.
|
||||
+ __Абстрактная фабрика (Abstract factory)__ - Класс, который представляет собой интерфейс для создания других классов.
|
||||
+ __Строитель (Builder)__ - Класс, который представляет собой интерфейс для создания сложного объекта.
|
||||
+ __Фабричный метод (Factory method)__ - Делегирует создание объектов наследникам родительского класса. Это позволяет использовать в коде программы не специфические классы, а манипулировать абстрактными объектами на более высоком уровне.
|
||||
+ __Прототип (Prototype)__ - Определяет интерфейс создания объекта через клонирование другого объекта вместо создания через конструктор.
|
||||
+ __Одиночка (Singleton)__ - Класс, который может иметь только один экземпляр.
|
||||
|
||||
[к оглавлению](#Шаблоны-проектирования)
|
||||
|
||||
## Приведите примеры структурных шаблонов проектирования.
|
||||
+ __Адаптер (Adapter)__ - Объект, обеспечивающий взаимодействие двух других объектов, один из которых использует, а другой предоставляет несовместимый с первым интерфейс.
|
||||
+ __Мост (Bridge)__ - Структура, позволяющая изменять интерфейс обращения и интерфейс реализации класса независимо.
|
||||
+ __Компоновщик (Composite)__ - Объект, который объединяет в себе объекты, подобные ему самому.
|
||||
+ __Декоратор (Decorator)__ - Класс, расширяющий функциональность другого класса без использования наследования.
|
||||
+ __Фасад (Facade)__ - Объект, который абстрагирует работу с несколькими классами, объединяя их в единое целое.
|
||||
+ __Приспособленец (Flyweight)__ - Это объект, представляющий себя как уникальный экземпляр в разных местах программы, но по факту не являющийся таковым.
|
||||
+ __Заместитель (Proxy)__ - Объект, который является посредником между двумя другими объектами, и который реализует/ограничивает доступ к объекту, к которому обращаются через него.
|
||||
|
||||
[к оглавлению](#Шаблоны-проектирования)
|
||||
|
||||
## Приведите примеры поведенческих шаблонов проектирования.
|
||||
+ __Цепочка обязанностей (Chain of responsibility)__ - Предназначен для организации в системе уровней ответственности.
|
||||
+ __Команда (Command)__ - Представляет действие. Объект команды заключает в себе само действие и его параметры.
|
||||
+ __Интерпретатор (Interpreter)__ - Решает часто встречающуюся, но подверженную изменениям, задачу.
|
||||
+ __Итератор (Iterator)__ - Представляет собой объект, позволяющий получить последовательный доступ к элементам объекта-агрегата без использования описаний каждого + __из объектов, входящих в состав агрегации.
|
||||
+ __Посредник (Mediator)__ - Обеспечивает взаимодействие множества объектов, формируя при этом слабую связанность и избавляя объекты от необходимости явно ссылаться друг на друга.
|
||||
+ __Хранитель (Memento)__ - Позволяет не нарушая инкапсуляцию зафиксировать и сохранить внутренние состояния объекта так, чтобы позднее восстановить его в этих состояниях.
|
||||
+ __Наблюдатель (Observer)__ - Определяет зависимость типа «один ко многим» между объектами таким образом, что при изменении состояния одного объекта все зависящие от него оповещаются об этом событии.
|
||||
+ __Состояние (State)__ - Используется в тех случаях, когда во время выполнения программы объект должен менять своё поведение в зависимости от своего состояния.
|
||||
+ __Стратегия (Strategy)__ - Предназначен для определения семейства алгоритмов, инкапсуляции каждого из них и обеспечения их взаимозаменяемости.
|
||||
+ __Шаблонный метод (Template method)__ - Определяет основу алгоритма и позволяет наследникам переопределять некоторые шаги алгоритма, не изменяя его структуру в целом.
|
||||
+ __Посетитель (Visitor)__ - Описывает операцию, которая выполняется над объектами других классов. При изменении класса Visitor нет необходимости изменять обслуживаемые классы.
|
||||
|
||||
[к оглавлению](#Шаблоны-проектирования)
|
||||
|
||||
## Что такое _«антипаттерн»_? Какие антипаттерны вы знаете?
|
||||
__Антипаттерн (anti-pattern)__ — это распространённый подход к решению класса часто встречающихся проблем, являющийся неэффективным, рискованным или непродуктивным.
|
||||
|
||||
__Poltergeists (полтергейсты)__ - это классы с ограниченной ответственностью и ролью в системе, чьё единственное предназначение — передавать информацию в другие классы. Их эффективный жизненный цикл непродолжителен. Полтергейсты нарушают стройность архитектуры программного обеспечения, создавая избыточные (лишние) абстракции, они чрезмерно запутанны, сложны для понимания и трудны в сопровождении. Обычно такие классы задумываются как классы-контроллеры, которые существуют только для вызова методов других классов, зачастую в предопределенной последовательности.
|
||||
|
||||
Признаки появления и последствия антипаттерна
|
||||
+ Избыточные межклассовые связи.
|
||||
+ Временные ассоциации.
|
||||
+ Классы без состояния (содержащие только методы и константы).
|
||||
+ Временные объекты и классы (с непродолжительным временем жизни).
|
||||
+ Классы с единственным методом, который предназначен только для создания или вызова других классов посредством временной ассоциации.
|
||||
+ Классы с именами методов в стиле «управления», такие как startProcess.
|
||||
|
||||
Типичные причины
|
||||
+ Отсутствие объектно-ориентированной архитектуры (архитектор не понимает объектно-ориентированной парадигмы).
|
||||
+ Неправильный выбор пути решения задачи.
|
||||
+ Предположения об архитектуре приложения на этапе анализа требований (до объектно-ориентированного анализа) могут также вести к проблемам на подобии этого антипаттерна.
|
||||
|
||||
__Внесенная сложность (Introduced complexity)__: Необязательная сложность дизайна. Вместо одного простого класса выстраивается целая иерархия интерфейсов и классов. Типичный пример «Интерфейс - Абстрактный класс - Единственный класс реализующий интерфейс на основе абстрактного».
|
||||
|
||||
__Инверсия абстракции (Abstraction inversion)__: Сокрытие части функциональности от внешнего использования, в надежде на то, что никто не будет его использовать.
|
||||
|
||||
__Неопределённая точка зрения (Ambiguous viewpoint)__: Представление модели без спецификации её точки рассмотрения.
|
||||
|
||||
__Большой комок грязи (Big ball of mud)__: Система с нераспознаваемой структурой.
|
||||
|
||||
__Божественный объект (God object)__: Концентрация слишком большого количества функций в одной части системы (классе).
|
||||
|
||||
__Затычка на ввод данных (Input kludge)__: Забывчивость в спецификации и выполнении поддержки возможного неверного ввода.
|
||||
|
||||
__Раздувание интерфейса (Interface bloat)__: Разработка интерфейса очень мощным и очень сложным для реализации.
|
||||
|
||||
__Волшебная кнопка (Magic pushbutton)__: Выполнение результатов действий пользователя в виде неподходящего (недостаточно абстрактного) интерфейса. Например, написание прикладной логики в обработчиках нажатий на кнопку.
|
||||
|
||||
__Перестыковка (Re-Coupling)__: Процесс внедрения ненужной зависимости.
|
||||
|
||||
__Дымоход (Stovepipe System)__: Редко поддерживаемая сборка плохо связанных компонентов.
|
||||
|
||||
__Состояние гонки (Race hazard)__: непредвидение возможности наступления событий в порядке, отличном от ожидаемого.
|
||||
|
||||
__Членовредительство (Mutilation)__: Излишнее «затачивание» объекта под определенную очень узкую задачу таким образом, что он не способен будет работать с никакими иными, пусть и очень схожими задачами.
|
||||
|
||||
__Сохранение или смерть (Save or die)__: Сохранение изменений лишь при завершении приложения.
|
||||
|
||||
[к оглавлению](#Шаблоны-проектирования)
|
||||
|
||||
## Что такое _Dependency Injection_?
|
||||
__Dependency Injection (внедрение зависимости)__ - это набор паттернов и принципов разработки програмного обеспечения, которые позволяют писать слабосвязный код. В полном соответствии с принципом единой обязанности объект отдаёт заботу о построении требуемых ему зависимостей внешнему, специально предназначенному для этого общему механизму.
|
||||
|
||||
[к оглавлению](#Шаблоны-проектирования)
|
||||
|
||||
# Источники
|
||||
+ [Википедия](https://ru.wikipedia.org/wiki/Шаблон_проектирования)
|
||||
+ [Javenue](http://www.javenue.info/post/56)
|
||||
|
|
@ -0,0 +1,157 @@
|
|||
[Вопросы для собеседования на Java Junior](README.md)
|
||||
|
||||
#Сериализация
|
||||
+ [Что такое _«сериализация»_?](#Что-такое-сериализация)
|
||||
+ [Опишите процесс сериализации/десериализации с использованием `Serializable`.](#Опишите-процесс-сериализациидесериализации-с-использованием-serializable)
|
||||
+ [Как изменить стандартное поведение сериализации/десериализации?](#Как-изменить-стандартное-поведение-сериализациидесериализации)
|
||||
+ [Как исключить поля из сериализации?](#Как-исключить-поля-из-сериализации)
|
||||
+ [Что обозначает ключевое слово `transient`?](#Что-обозначает-ключевое-слово-transient)
|
||||
+ [Какое влияние оказывают на сериализуемость модификаторы полей `static` и `final`](#Какое-влияние-оказывают-на-сериализуемость-модификаторы-полей-static-и-final)
|
||||
+ [Как не допустить сериализацию?](#Как-не-допустить-сериализацию)
|
||||
+ [Как создать собственный протокол сериализации?](#Как-создать-собственный-протокол-сериализации)
|
||||
+ [Какая роль поля `serialVersionUID` в сериализации?](#Какая-роль-поля-serialversionuid-в-сериализации)
|
||||
+ [Когда стоит изменять значение поля `serialVersionUID`?](#Когда-стоит-изменять-значение-поля-serialversionuid)
|
||||
+ [В чем проблема сериализации Singleton?](#В-чем-проблема-сериализации-singleton)
|
||||
+ [Какие существуют способы контроля за значениями десериализованного объекта](#Какие-существуют-способы-контроля-за-значениями-десериализованного-объекта)
|
||||
|
||||
##Что такое _«сериализация»_?
|
||||
__Сериализация (Serialization)__ - процесс преобразования структуры данных в линейную последовательность байтов для дальнейшей передачи или сохранения. Сериализованные объекты можно затем восстановить (десериализовать).
|
||||
|
||||
В Java, согласно спецификации Java Object Serialization существует два стандартных способа сериализации: стандартная сериализация, через использование интерфейса `java.io.Serializable` и «расширенная» сериализация - `java.io.Externalizable`.
|
||||
|
||||
Сериализация позволяет в определенных пределах изменять класс. Вот наиболее важные изменения, с которыми спецификация Java Object Serialization может справляться автоматически:
|
||||
|
||||
+ добавление в класс новых полей;
|
||||
+ изменение полей из статических в нестатические;
|
||||
+ изменение полей из транзитных в нетранзитные.
|
||||
|
||||
Обратные изменения (из нестатических полей в статические и из нетранзитных в транзитные) или удаление полей требуют определенной дополнительной обработки в зависимости от того, какая степень обратной совместимости необходима.
|
||||
|
||||
[к оглавлению](#Сериализация)
|
||||
|
||||
##Опишите процесс сериализации/десериализации с использованием `Serializable`.
|
||||
При использовании Serializable применяется алгоритм сериализации, который с помощью рефлексии (Reflection API) выполняет:
|
||||
|
||||
+ запись в поток метаданных о классе, ассоциированном с объектом (имя класса, идентификатор `SerialVersionUID`, идентификаторы полей класса);
|
||||
+ рекурсивную запись в поток описания суперклассов до класса `java.lang.Object` (не включительно);
|
||||
+ запись примитивных значений полей сериализуемого экземпляра, начиная с полей самого верхнего суперкласса;
|
||||
+ рекурсивную запись объектов, которые являются полями сериализуемого объекта.
|
||||
|
||||
При этом ранее сериализованные объекты повторно не сериализуются, что позволяет алгоритму корректно работать с циклическими ссылками.
|
||||
|
||||
Для выполнения десериализации под объект выделяется память, после чего его поля заполняются значениями из потока. Конструктор объекта при этом не вызывается. Однако при десериализации будет вызван конструктор без параметров родительского несериализуемого класса, а его отсутствие повлечёт ошибку десериализации.
|
||||
|
||||
[к оглавлению](#Сериализация)
|
||||
|
||||
##Как изменить стандартное поведение сериализации/десериализации?
|
||||
+ Реализовать интерфейс `java.io.Externalizable`, который позволяет применение пользовательской логики сериализации. Способ сериализации и десериализации описывается в методах `writeExternal()`` и `readExternal()`. Во время десериализации вызывается конструктор без параметров, а потом уже на созданном объекте вызывается метод `readExternal`.
|
||||
+ Если у сериализуемого объекта реализован один из следующих методов, то механизм сериализации будет использовать его, а не метод по умолчанию :
|
||||
+ `writeObject()` - запись объекта в поток;
|
||||
+ `readObject()` - чтение объекта из потока;
|
||||
+ `writeReplace()` - позволяет заменить себя экземпляром другого класса перед записью;
|
||||
+ `readResolve()` - позволяет заменить на себя другой объект после чтения.
|
||||
|
||||
[к оглавлению](#Сериализация)
|
||||
|
||||
##Как исключить поля из сериализации?
|
||||
Для управления сериализацией при определении полей можно использовать ключевое слово `transient`, таким образом исключив поля из общего процесса сериализации.
|
||||
|
||||
[к оглавлению](#Сериализация)
|
||||
|
||||
##Что обозначает ключевое слово `transient`?
|
||||
Поля класса, помеченные модификатором `transient`, не сериализуются.
|
||||
|
||||
Обычно в таких полях хранится промежуточное состояние объекта, которое, к примеру, проще вычислить. Другой пример такого поля - ссылка на экземпляр объекта, который не требует сериализации или не может быть сериализован.
|
||||
|
||||
[к оглавлению](#Сериализация)
|
||||
|
||||
##Какое влияние оказывают на сериализуемость модификаторы полей `static` и `final`
|
||||
При стандартной сериализации поля, имеющие модификатор static, не сериализуются. Соответственно, после десериализации это поле значения не меняет. При использовании реализации `Externalizable` сериализовать и десериализовать статическое поле можно, но не рекомендуется этого делать, т.к. это может сопровождаться трудноуловимыми ошибками.
|
||||
|
||||
Поля с модификатором `final` сериализуются как и обычные. За одним исключением – их невозможно десериализовать при использовании `Externalizable`, поскольку `final` поля должны быть инициализированы в конструкторе, а после этого в `readExternal()` изменить значение этого поля будет невозможно. Соответственно, если необходимо сериализовать объект с `final` полем необходимо использовать только стандартную сериализацию.
|
||||
|
||||
[к оглавлению](#Сериализация)
|
||||
|
||||
##Как не допустить сериализацию?
|
||||
Чтобы не допустить автоматическую сериализацию можно переопределить `private` методы для создания исключительной ситуации `NotSerializableException`.
|
||||
|
||||
```java
|
||||
private void writeObject(ObjectOutputStream out) throws IOException {
|
||||
throw new NotSerializableException();
|
||||
}
|
||||
|
||||
private void readObject(ObjectInputStream in) throws IOException {
|
||||
throw new NotSerializableException();
|
||||
}
|
||||
```
|
||||
|
||||
Любая попытка записать или прочитать этот объект теперь приведет к возникновению исключительной ситуации.
|
||||
|
||||
[к оглавлению](#Сериализация)
|
||||
|
||||
##Как создать собственный протокол сериализации?
|
||||
Для создания собственного протокола сериализации достаточно реализовать интерфейс `Externalizable`, который содержит два метода:
|
||||
|
||||
```java
|
||||
public void writeExternal(ObjectOutput out) throws IOException;
|
||||
public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException;
|
||||
```
|
||||
|
||||
[к оглавлению](#Сериализация)
|
||||
|
||||
##Какая роль поля `serialVersionUID` в сериализации?
|
||||
`serialVersionUID` используется для указании версии сериализованных данных.
|
||||
|
||||
Когда мы не объявляем `serialVersionUID` в нашем классе явно, среда выполнения Java делает это за нас, но этот процесс чувствителен ко многим метаданным класса включая количество полей, тип полей, модификаторы доступа полей, интерфейсов, которые реализованы в классе и пр.
|
||||
|
||||
Рекомендуется явно объявлять `serialVersionUID` т.к. при добавлении, удалении атрибутов класса динамически сгенерированное значение может измениться и в момент выполнения будет выброшено исключение `InvalidClassException`.
|
||||
|
||||
```java
|
||||
private static final long serialVersionUID = 20161013L;
|
||||
```
|
||||
[к оглавлению](#Сериализация)
|
||||
|
||||
##Когда стоит изменять значение поля `serialVersionUID`?
|
||||
`serialVersionUID` нужно изменять при внесении в класс несовместимых изменений, например при удалении какого-либо его атрибута.
|
||||
|
||||
[к оглавлению](#Сериализация)
|
||||
|
||||
##В чем проблема сериализации Singleton?
|
||||
Проблема в том что после десериализации мы получим другой объект. Таким образом, сериализация дает возможность создать Singleton еще раз, что недопустимо. Существует два способа избежать этого:
|
||||
|
||||
+ явный запрет сериализации.
|
||||
+ определение метода с сигнатурой `(default/public/private/protected/) Object readResolve() throws ObjectStreamException`, назначением которого станет возврат замещающего объекта вместо объекта, на котором он вызван.
|
||||
|
||||
[к оглавлению](#Сериализация)
|
||||
|
||||
##Какие существуют способы контроля за значениями десериализованного объекта
|
||||
Если есть необходимость выполнения контроля за значениями десериализованного объекта, то можно использовать интерфейс `ObjectInputValidation` с переопределением метода `validateObject()`.
|
||||
|
||||
```java
|
||||
// Если вызвать метод validateObject() после десериализации объекта, то будет вызвано исключение InvalidObjectException при значении возраста за пределами 39...60.
|
||||
public class Person implements java.io.Serializable,
|
||||
java.io.ObjectInputValidation {
|
||||
...
|
||||
@Override
|
||||
public void validateObject() throws InvalidObjectException {
|
||||
if ((age < 39) || (age > 60))
|
||||
throw new InvalidObjectException("Invalid age");
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
Так же существуют способы подписывания и шифрования, позволяющие убедиться, что данные не были изменены:
|
||||
|
||||
+ с помощью описания логики в `writeObject()` и `readObject()`.
|
||||
|
||||
+ поместить в оберточный класс `javax.crypto.SealedObject` и/или `java.security.SignedObject`. Данные классы являются сериализуемыми, поэтому при оборачивании объекта в `SealedObject` создается подобие «подарочной упаковки» вокруг исходного объекта. Для шифрования необходимо создать симметричный ключ, управление которым должно осуществляться отдельно. Аналогично, для проверки данных можно использовать класс `SignedObject`, для работы с которым также нужен симметричный ключ, управляемый отдельно.
|
||||
|
||||
[к оглавлению](#Сериализация)
|
||||
|
||||
|
||||
#Источники
|
||||
+ [IBM developerWorks](https://www.ibm.com/developerworks/ru/library/j-5things1/)
|
||||
+ [Java-online.ru](http://java-online.ru/blog-serialization.xhtml)
|
||||
+ [Изучите секреты Java Serialization API](http://ccfit.nsu.ru/~deviv/courses/oop/java_ser_rus.html)
|
||||
+ [JavaRush](http://bit.ly/1xwRA2D)
|
||||
+ [Записки трезвого практика](http://www.skipy.ru/technics/serialization.html)
|
||||
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,396 @@
|
|||
[Вопросы для собеседования на Java Junior](README.md)
|
||||
|
||||
#SQL
|
||||
+ [Что такое _«SQL»_?](#Что-такое-sql)
|
||||
+ [Какие существуют операторы SQL?](#Какие-существуют-операторы-sql)
|
||||
+ [Что означает `NULL` в SQL?](#Что-означает-null-в-sql)
|
||||
+ [Что такое _«временная таблица»_? Для чего она используется?](#Что-такое-временная-таблица-Для-чего-она-используется)
|
||||
+ [Что такое _«представление» (view)_ и для чего оно применяется?](#Что-такое-представление-view-и-для-чего-оно-применяется)
|
||||
+ [Каков общий синтаксис оператора `SELECT`?](#Каков-общий-синтаксис-оператора-select)
|
||||
+ [Что такое `JOIN`?](#Что-такое-join)
|
||||
+ [Какие существуют типы `JOIN`?](#Какие-существуют-типы-join)
|
||||
+ [Что лучше использовать `JOIN` или подзапросы?](#Что-лучше-использовать-join-или-подзапросы)
|
||||
+ [Для чего используется оператор `HAVING`?](#Для-чего-используется-оператор-having)
|
||||
+ [В чем различие между операторами `HAVING` и `WHERE`?](#В-чем-различие-между-операторами-having-и-where)
|
||||
+ [Для чего используется оператор `ORDER BY`?](#Для-чего-используется-оператор-order-by)
|
||||
+ [Для чего используется оператор `GROUP BY`?](#Для-чего-используется-оператор-group-by)
|
||||
+ [Как `GROUP BY` обрабатывает значение `NULL`?](#Как-group-by-обрабатывает-значение-null)
|
||||
+ [В чем разница между операторами `GROUP BY` и `DISTINCT`?](#В-чем-разница-между-операторами-group-by-и-distinct)
|
||||
+ [Перечислите основные агрегатные функции.](#Перечислите-основные-агрегатные-функции)
|
||||
+ [В чем разница между `COUNT(*)` и `COUNT({column})`?](#В-чем-разница-между-count-и-countcolumn)
|
||||
+ [Что делает оператор `EXISTS`?](#Что-делает-оператор-exists)
|
||||
+ [Для чего используются операторы `IN`, `BETWEEN`, `LIKE`?](#Для-чего-используются-операторы-in-between-like)
|
||||
+ [Для чего применяется ключевое слово `UNION`?](#Для-чего-применяется-ключевое-слово-union)
|
||||
+ [Какие ограничения на целостность данных существуют в SQL?](#Какие-ограничения-на-целостность-данных-существуют-в-sql)
|
||||
+ [Какие отличия между ограничениями `PRIMARY` и `UNIQUE`?](#Какие-отличия-между-ограничениями-primary-и-unique)
|
||||
+ [Может ли значение в столбце, на который наложено ограничение `FOREIGN KEY`, равняться `NULL`?](#Может-ли-значение-в-столбце-на-который-наложено-ограничение-foreign-key-равняться-null)
|
||||
+ [Как создать индекс?](#Как-создать-индекс)
|
||||
+ [Что делает оператор `MERGE`?](#Что-делает-оператор-merge)
|
||||
+ [В чем отличие между операторами `DELETE` и `TRUNCATE`?](#В-чем-отличие-между-операторами-delete-и-truncate)
|
||||
+ [Что такое _«хранимая процедура»_?](#Что-такое-хранимая-процедура)
|
||||
+ [Что такое _«триггер»_?](#Что-такое-триггер)
|
||||
+ [Что такое _«курсор»_?](#Что-такое-курсор)
|
||||
+ [Опишите разницу типов данных `DATETIME` и `TIMESTAMP`.](#Опишите-разницу-типов-данных-datetime-и-timestamp)
|
||||
+ [Для каких числовых типов недопустимо использовать операции сложения/вычитания?](#Для-каких-числовых-типов-недопустимо-использовать-операции-сложениявычитания)
|
||||
+ [Какое назначение у операторов `PIVOT` и `UNPIVOT` в Transact-SQL?](#Какое-назначение-у-операторов-pivot-и-unpivot-в-transact-sql)
|
||||
+ [Расскажите об основных функциях ранжирования в Transact-SQL.](#Расскажите-об-основных-функциях-ранжирования-в-transact-sql)
|
||||
+ [Для чего используются операторы `INTERSECT`, `EXCEPT` в Transact-SQL?](#Для-чего-используются-операторы-intersect-except-в-transact-sql)
|
||||
+ [Напишите запрос...](#Напишите-запрос)
|
||||
|
||||
##Что такое _«SQL»_?
|
||||
SQL, Structured query language («язык структурированных запросов») — формальный непроцедурный язык программирования, применяемый для создания, модификации и управления данными в произвольной реляционной базе данных, управляемой соответствующей системой управления базами данных (СУБД).
|
||||
|
||||
[к оглавлению](#sql)
|
||||
|
||||
##Какие существуют операторы SQL?
|
||||
__операторы определения данных (Data Definition Language, DDL)__:
|
||||
|
||||
+ `CREATE` создает объект БД (базу, таблицу, представление, пользователя и т. д.),
|
||||
+ `ALTER` изменяет объект,
|
||||
+ `DROP` удаляет объект;
|
||||
|
||||
__операторы манипуляции данными (Data Manipulation Language, DML)__:
|
||||
|
||||
+ `SELECT` выбирает данные, удовлетворяющие заданным условиям,
|
||||
+ `INSERT` добавляет новые данные,
|
||||
+ `UPDATE` изменяет существующие данные,
|
||||
+ `DELETE` удаляет данные;
|
||||
|
||||
__операторы определения доступа к данным (Data Control Language, DCL)__:
|
||||
|
||||
+ `GRANT` предоставляет пользователю (группе) разрешения на определенные операции с объектом,
|
||||
+ `REVOKE` отзывает ранее выданные разрешения,
|
||||
+ `DENY` задает запрет, имеющий приоритет над разрешением;
|
||||
|
||||
__операторы управления транзакциями (Transaction Control Language, TCL)__:
|
||||
|
||||
+ `COMMIT` применяет транзакцию,
|
||||
+ `ROLLBACK` откатывает все изменения, сделанные в контексте текущей транзакции,
|
||||
+ `SAVEPOINT` разбивает транзакцию на более мелкие.
|
||||
|
||||
[к оглавлению](#sql)
|
||||
|
||||
##Что означает `NULL` в SQL?
|
||||
`NULL` - специальное значение (псевдозначение), которое может быть записано в поле таблицы базы данных. NULL соответствует понятию «пустое поле», то есть «поле, не содержащее никакого значения».
|
||||
|
||||
`NULL` означает отсутствие, неизвестность информации. Значение `NULL` не является значением в полном смысле слова: по определению оно означает отсутствие значения и не принадлежит ни одному типу данных. Поэтому `NULL` не равно ни логическому значению `FALSE`, ни _пустой строке_, ни `0`. При сравнении `NULL` с любым значением будет получен результат `NULL`, а не `FALSE` и не `0`. Более того, `NULL` не равно `NULL`!
|
||||
|
||||
[к оглавлению](#sql)
|
||||
|
||||
##Что такое _«временная таблица»_? Для чего она используется?
|
||||
__Временная таблица__ - это объект базы данных, который хранится и управляется системой базы данных на временной основе. Они могут быть локальными или глобальными. Используется для сохранения результатов вызова хранимой процедуры, уменьшение числа строк при соединениях, агрегирование данных из различных источников или как замена курсоров и параметризованных представлений.
|
||||
|
||||
[к оглавлению](#sql)
|
||||
|
||||
##Что такое _«представление» (view)_ и для чего оно применяется?
|
||||
__Представление__, View - виртуальная таблица, представляющая данные одной или более таблиц альтернативным образом.
|
||||
|
||||
В действительности представление – всего лишь результат выполнения оператора `SELECT`, который хранится в структуре памяти, напоминающей SQL таблицу. Они работают в запросах и операторах DML точно также как и основные таблицы, но не содержат никаких собственных данных. Представления значительно расширяют возможности управления данными. Это способ дать публичный доступ к некоторой (но не всей) информации в таблице.
|
||||
|
||||
[к оглавлению](#sql)
|
||||
|
||||
##Каков общий синтаксис оператора `SELECT`?
|
||||
`SELECT` - оператор DML SQL, возвращающий набор данных (выборку) из базы данных, удовлетворяющих заданному условию. Имеет следующую структуру:
|
||||
|
||||
```sql
|
||||
SELECT
|
||||
[DISTINCT | DISTINCTROW | ALL]
|
||||
select_expression,...
|
||||
FROM table_references
|
||||
[WHERE where_definition]
|
||||
[GROUP BY {unsigned_integer | column | formula}]
|
||||
[HAVING where_definition]
|
||||
[ORDER BY {unsigned_integer | column | formula} [ASC | DESC], ...]
|
||||
```
|
||||
|
||||
[к оглавлению](#sql)
|
||||
|
||||
##Что такое `JOIN`?
|
||||
__JOIN__ - оператор языка SQL, который является реализацией операции соединения реляционной алгебры. Предназначен для обеспечения выборки данных из двух таблиц и включения этих данных в один результирующий набор.
|
||||
|
||||
Особенностями операции соединения являются следующее:
|
||||
|
||||
+ в схему таблицы-результата входят столбцы обеих исходных таблиц (таблиц-операндов), то есть схема результата является «сцеплением» схем операндов;
|
||||
+ каждая строка таблицы-результата является «сцеплением» строки из одной таблицы-операнда со строкой второй таблицы-операнда;
|
||||
+ при необходимости соединения не двух, а нескольких таблиц, операция соединения применяется несколько раз (последовательно).
|
||||
|
||||
```sql
|
||||
SELECT
|
||||
field_name [,... n]
|
||||
FROM
|
||||
Table1
|
||||
{INNER | {LEFT | RIGHT | FULL} OUTER | CROSS } JOIN
|
||||
Table2
|
||||
{ON <condition> | USING (field_name [,... n])}
|
||||
```
|
||||
|
||||
[к оглавлению](#sql)
|
||||
|
||||
##Какие существуют типы `JOIN`?
|
||||
__(INNER) JOIN__
|
||||
Результатом объединения таблиц являются записи, общие для левой и правой таблиц. Порядок таблиц для оператора не важен, поскольку оператор является симметричным.
|
||||
|
||||
__LEFT (OUTER) JOIN__
|
||||
Производит выбор всех записей первой таблицы и соответствующих им записей второй таблицы. Если записи во второй таблице не найдены, то вместо них подставляется пустой результат (`NULL`). Порядок таблиц для оператора важен, поскольку оператор не является симметричным.
|
||||
|
||||
__RIGHT (OUTER) JOIN__
|
||||
`LEFT JOIN` с операндами, расставленными в обратном порядке. Порядок таблиц для оператора важен, поскольку оператор не является симметричным.
|
||||
|
||||
__FULL (OUTER) JOIN__
|
||||
Результатом объединения таблиц являются все записи, которые присутствуют в таблицах. Порядок таблиц для оператора не важен, поскольку оператор является симметричным.
|
||||
|
||||
__CROSS JOIN (декартово произведение)__
|
||||
При выборе каждая строка одной таблицы объединяется с каждой строкой второй таблицы, давая тем самым все возможные сочетания строк двух таблиц. Порядок таблиц для оператора не важен, поскольку оператор является симметричным.
|
||||
|
||||
[к оглавлению](#sql)
|
||||
|
||||
##Что лучше использовать `JOIN` или подзапросы?
|
||||
Обычно лучше использовать `JOIN`, поскольку в большинстве случаев он более понятен и лучше оптимизируется СУБД (но 100% этого гарантировать нельзя). Так же `JOIN` имеет заметное преимущество над подзапросами в случае, когда список выбора `SELECT` содержит столбцы более чем из одной таблицы.
|
||||
|
||||
Подзапросы лучше использовать в случаях, когда нужно вычислять агрегатные значения и использовать их для сравнений во внешних запросах.
|
||||
|
||||
[к оглавлению](#sql)
|
||||
|
||||
##Для чего используется оператор `HAVING`?
|
||||
`HAVING` используется для фильтрации результата `GROUP BY` по заданным логическим условиям.
|
||||
|
||||
[к оглавлению](#sql)
|
||||
|
||||
##В чем различие между операторами `HAVING` и `WHERE`?
|
||||
`HAVING` используется как `WHERE`, но в другой части SQL-выражения и, соответственно, на другой стадии формирования ответа.
|
||||
|
||||
[к оглавлению](#sql)
|
||||
|
||||
##Для чего используется оператор `ORDER BY`?
|
||||
__ORDER BY__ упорядочивает вывод запроса согласно значениям в том или ином количестве выбранных столбцов. Многочисленные столбцы упорядочиваются один внутри другого. Возможно определять возрастание `ASC` или убывание `DESC` для каждого столбца. По умолчанию установлено - возрастание.
|
||||
|
||||
[к оглавлению](#sql)
|
||||
|
||||
##Для чего используется оператор `GROUP BY`?
|
||||
`GROUP BY` используется для агрегации записей результата по заданным признакам-атрибутам.
|
||||
|
||||
[к оглавлению](#sql)
|
||||
|
||||
##Как `GROUP BY` обрабатывает значение `NULL`?
|
||||
При использовании `GROUP BY` все значения `NULL` считаются равными.
|
||||
|
||||
[к оглавлению](#sql)
|
||||
|
||||
##В чем разница между операторами `GROUP BY` и `DISTINCT`?
|
||||
`DISTINCT` указывает, что для вычислений используются только уникальные значения столбца. `NULL` считается как отдельное значение.
|
||||
`GROUP BY` создает отдельную группу для всех возможных значений (включая значение `NULL`).
|
||||
|
||||
Если нужно удалить только дубликаты лучше использовать `DISTINCT`, `GROUP BY` лучше использовать для определения групп записей, к которым могут применяться агрегатные функции.
|
||||
|
||||
[к оглавлению](#sql)
|
||||
|
||||
##Перечислите основные агрегатные функции.
|
||||
__Агрегатных функции__ - функции, которые берут группы значений и сводят их к одиночному значению.
|
||||
|
||||
SQL предоставляет несколько агрегатных функций:
|
||||
|
||||
`COUNT` - производит подсчет записей, удовлетворяющих условию запроса;
|
||||
`SUM` - вычисляет арифметическую сумму всех значений колонки;
|
||||
`AVG` - вычисляет среднее арифметическое всех значений;
|
||||
`MAX` - определяет наибольшее из всех выбранных значений;
|
||||
`MIN` - определяет наименьшее из всех выбранных значений.
|
||||
|
||||
[к оглавлению](#sql)
|
||||
|
||||
##В чем разница между `COUNT(*)` и `COUNT({column})`?
|
||||
`COUNT (*)` подсчитывает количество записей в таблице, не игнорируя значение NULL, поскольку эта функция оперирует записями, а не столбцами.
|
||||
|
||||
`COUNT ({column})` подсчитывает количество значений в `{column}`. При подсчете количества значений столбца эта форма функции `COUNT` не принимает во внимание значение `NULL`.
|
||||
|
||||
[к оглавлению](#sql)
|
||||
|
||||
##Что делает оператор `EXISTS`?
|
||||
`EXISTS` берет подзапрос, как аргумент, и оценивает его как `TRUE`, если подзапрос возвращает какие-либо записи и `FALSE`, если нет.
|
||||
|
||||
[к оглавлению](#sql)
|
||||
|
||||
##Для чего используются операторы `IN`, `BETWEEN`, `LIKE`?
|
||||
`IN` - определяет набор значений.
|
||||
|
||||
```sql
|
||||
SELECT * FROM Persons WHERE name IN ('Ivan','Petr','Pavel');
|
||||
```
|
||||
|
||||
`BETWEEN` определяет диапазон значений. В отличие от `IN`, `BETWEEN` чувствителен к порядку, и первое значение в предложении должно быть первым по алфавитному или числовому порядку.
|
||||
|
||||
```sql
|
||||
SELECT * FROM Persons WHERE age BETWEEN 20 AND 25;
|
||||
```
|
||||
|
||||
`LIKE` применим только к полям типа `CHAR` или `VARCHAR`, с которыми он используется чтобы находить подстроки. В качестве условия используются _символы шаблонизации (wildkards_) - специальные символы, которые могут соответствовать чему-нибудь:
|
||||
|
||||
+ `_` замещает любой одиночный символ. Например, `'b_t'` будет соответствовать словам `'bat'` или `'bit'`, но не будет соответствовать `'brat'`.
|
||||
|
||||
+ `%` замещает последовательность любого числа символов. Например `'%p%t'` будет соответствовать словам `'put'`, `'posit'`, или `'opt'`, но не `'spite'`.
|
||||
|
||||
```sql
|
||||
SELECT * FROM UNIVERSITY WHERE NAME LIKE '%o';
|
||||
```
|
||||
|
||||
[к оглавлению](#sql)
|
||||
|
||||
##Для чего применяется ключевое слово `UNION`?
|
||||
В языке SQL ключевое слово `UNION` применяется для объединения результатов двух SQL-запросов в единую таблицу, состоящую из схожих записей. Оба запроса должны возвращать одинаковое число столбцов и совместимые типы данных в соответствующих столбцах. Необходимо отметить, что `UNION` сам по себе не гарантирует порядок записей. Записи из второго запроса могут оказаться в начале, в конце или вообще перемешаться с записями из первого запроса. В случаях, когда требуется определенный порядок, необходимо использовать `ORDER BY`.
|
||||
|
||||
[к оглавлению](#sql)
|
||||
|
||||
##Какие ограничения на целостность данных существуют в SQL?
|
||||
`PRIMARY KEY` - набор полей (1 или более), значения которых образуют уникальную комбинацию и используются для однозначной идентификации записи в таблице. Для таблицы может быть создано только одно такое ограничение. Данное ограничение используется для обеспечения целостности сущности, которая описана таблицей.
|
||||
|
||||
`CHECK` используется для ограничения множества значений, которые могут быть помещены в данный столбец. Это ограничение используется для обеспечения целостности предметной области, которую описывают таблицы в базе.
|
||||
|
||||
`UNIQUE` обеспечивает отсутствие дубликатов в столбце или наборе столбцов.
|
||||
|
||||
`FOREIGN KEY` защищает от действий, которые могут нарушить связи между таблицами. `FOREIGN KEY` в одной таблице указывает на `PRIMARY KEY` в другой. Поэтому данное ограничение нацелено на то, чтобы не было записей `FOREIGN KEY`, которым не отвечают записи `PRIMARY KEY`.
|
||||
|
||||
[к оглавлению](#sql)
|
||||
|
||||
##Какие отличия между ограничениями `PRIMARY` и `UNIQUE`?
|
||||
По умолчанию ограничение `PRIMARY` создает кластерный индекс на столбце, а `UNIQUE` - некластерный. Другим отличием является то, что `PRIMARY` не разрешает `NULL` записей, в то время как `UNIQUE` разрешает одну (а в некоторых СУБД несколько) `NULL` запись.
|
||||
|
||||
[к оглавлению](#sql)
|
||||
|
||||
##Может ли значение в столбце, на который наложено ограничение `FOREIGN KEY`, равняться `NULL`?
|
||||
Может, если на данный столбец не наложено ограничение `NOT NULL`.
|
||||
|
||||
[к оглавлению](#sql)
|
||||
|
||||
##Как создать индекс?
|
||||
Индекс можно создать либо с помощью выражения `CREATE INDEX`:
|
||||
```sql
|
||||
CREATE INDEX index_name ON table_name (column_name)
|
||||
```
|
||||
|
||||
либо указав ограничение целостности в виде уникального `UNIQUE` или первичного `PRIMARY` ключа в операторе создания таблицы `CREATE TABLE`.
|
||||
|
||||
[к оглавлению](#sql)
|
||||
|
||||
##Что делает оператор `MERGE`?
|
||||
`MERGE` позволяет осуществить слияние данных одной таблицы с данными другой таблицы. При слиянии таблиц проверяется условие, и если оно истинно, то выполняется `UPDATE`, а если нет - `INSERT`. При этом изменять поля таблицы в секции `UPDATE`, по которым идет связывание двух таблиц, нельзя.
|
||||
|
||||
[к оглавлению](#sql)
|
||||
|
||||
##В чем отличие между операторами `DELETE` и `TRUNCATE`?
|
||||
`DELETE` - оператор DML, удаляет записи из таблицы, которые удовлетворяют критерию `WHERE` при этом задействуются триггеры, ограничения и т.д.
|
||||
|
||||
`TRUNCATE` - DDL оператор (удаляет таблицу и создает ее заново. Причем если на эту таблицу есть ссылки `FOREGIN KEY` или таблица используется в репликации, то пересоздать такую таблицу не получится).
|
||||
|
||||
[к оглавлению](#sql)
|
||||
|
||||
##Что такое _«хранимая процедура»_?
|
||||
__Хранимая процедура__ — объект базы данных, представляющий собой набор SQL-инструкций, который хранится на сервере. Хранимые процедуры очень похожи на обыкновенные процедуры языков высокого уровня, у них могут быть входные и выходные параметры и локальные переменные, в них могут производиться числовые вычисления и операции над символьными данными, результаты которых могут присваиваться переменным и параметрам. В хранимых процедурах могут выполняться стандартные операции с базами данных (как DDL, так и DML). Кроме того, в хранимых процедурах возможны циклы и ветвления, то есть в них могут использоваться инструкции управления процессом исполнения.
|
||||
|
||||
Хранимые процедуры позволяют повысить производительность, расширяют возможности программирования и поддерживают функции безопасности данных. В большинстве СУБД при первом запуске хранимой процедуры она компилируется (выполняется синтаксический анализ и генерируется план доступа к данным) и в дальнейшем её обработка осуществляется быстрее.
|
||||
|
||||
[к оглавлению](#sql)
|
||||
|
||||
##Что такое _«триггер»_?
|
||||
__Триггер (trigger)__ — это хранимая процедура особого типа, которую пользователь не вызывает непосредственно, а исполнение которой обусловлено действием по модификации данных: добавлением, удалением или изменением данных в заданной таблице реляционной базы данных. Триггеры применяются для обеспечения целостности данных и реализации сложной бизнес-логики. Триггер запускается сервером автоматически и все производимые им модификации данных рассматриваются как выполняемые в транзакции, в которой выполнено действие, вызвавшее срабатывание триггера. Соответственно, в случае обнаружения ошибки или нарушения целостности данных может произойти откат этой транзакции.
|
||||
|
||||
Момент запуска триггера определяется с помощью ключевых слов `BEFORE` (триггер запускается до выполнения связанного с ним события) или `AFTER` (после события). В случае, если триггер вызывается до события, он может внести изменения в модифицируемую событием запись. Кроме того, триггеры могут быть привязаны не к таблице, а к представлению (VIEW). В этом случае с их помощью реализуется механизм «обновляемого представления». В этом случае ключевые слова `BEFORE` и `AFTER` влияют лишь на последовательность вызова триггеров, так как собственно событие (удаление, вставка или обновление) не происходит.
|
||||
|
||||
[к оглавлению](#sql)
|
||||
|
||||
##Что такое _«курсор»_?
|
||||
__Курсор__ — это объект базы данных, который позволяет приложениям работать с записями «по-одной», а не сразу с множеством, как это делается в обычных SQL командах.
|
||||
|
||||
Порядок работы с курсором такой:
|
||||
|
||||
+ Определить курсор (`DECLARE`)
|
||||
+ Открыть курсор (`OPEN`)
|
||||
+ Получить запись из курсора (`FETCH`)
|
||||
+ Обработать запись...
|
||||
+ Закрыть курсор (`CLOSE`)
|
||||
+ Удалить ссылку курсора (`DEALLOCATE`). Когда удаляется последняя ссылка курсора, SQL освобождает структуры данных, составляющие курсор.
|
||||
|
||||
[к оглавлению](#sql)
|
||||
|
||||
##Опишите разницу типов данных `DATETIME` и `TIMESTAMP`.
|
||||
`DATETIME` предназначен для хранения целого числа: `YYYYMMDDHHMMSS`. И это время не зависит от временной зоны настроенной на сервере.
|
||||
Размер: 8 байт
|
||||
|
||||
`TIMESTAMP` хранит значение равное количеству секунд, прошедших с полуночи 1 января 1970 года по усреднённому времени Гринвича. При получении из базы отображается с учётом часового пояса. Размер: 4 байта
|
||||
|
||||
[к оглавлению](#sql)
|
||||
|
||||
##Для каких числовых типов недопустимо использовать операции сложения/вычитания?
|
||||
В качестве операндов операций сложения и вычитания нельзя использовать числовой тип `BIT`.
|
||||
|
||||
[к оглавлению](#sql)
|
||||
|
||||
##Какое назначение у операторов `PIVOT` и `UNPIVOT` в Transact-SQL?
|
||||
`PIVOT` и `UNPIVOT` являются нестандартными реляционными операторами, которые поддерживаются Transact-SQL.
|
||||
|
||||
Оператор `PIVOT` разворачивает возвращающее табличное значение выражение, преобразуя уникальные значения одного столбца выражения в несколько выходных столбцов, а также, в случае необходимости, объединяет оставшиеся повторяющиеся значения столбца и отображает их в выходных данных. Оператор `UNPIVOT` производит действия, обратные `PIVOT`, преобразуя столбцы возвращающего табличное значение выражения в значения столбца.
|
||||
|
||||
[к оглавлению](#sql)
|
||||
|
||||
##Расскажите об основных функциях ранжирования в Transact-SQL.
|
||||
Ранжирующие функции - это функции, которые возвращают значение для каждой записи группы в результирующем наборе данных. На практике они могут быть использованы, например, для простой нумерации списка, составления рейтинга или постраничной навигации.
|
||||
|
||||
`ROW_NUMBER` – функция нумерации в Transact-SQL, которая возвращает просто номер записи.
|
||||
|
||||
`RANK` возвращает ранг каждой записи. В данном случае, в отличие от `ROW_NUMBER`, идет уже анализ значений и в случае нахождения одинаковых возвращает одинаковый ранг с пропуском следующего.
|
||||
|
||||
`DENSE_RANK` так же возвращает ранг каждой записи, но в отличие от `RANK` в случае нахождения одинаковых значений возвращает ранг без пропуска следующего.
|
||||
|
||||
`NTILE` – функция Transact-SQL, которая делит результирующий набор на группы по определенному столбцу.
|
||||
|
||||
[к оглавлению](#sql)
|
||||
|
||||
##Для чего используются операторы `INTERSECT`, `EXCEPT` в Transact-SQL?
|
||||
Оператор `EXCEPT` возвращает уникальные записи из левого входного запроса, которые не выводятся правым входным запросом.
|
||||
|
||||
Оператор `INTERSECT` возвращает уникальные записи, выводимые левым и правым входными запросами.
|
||||
|
||||
[к оглавлению](#sql)
|
||||
|
||||
##Напишите запрос...
|
||||
```sql
|
||||
CREATE TABLE table (
|
||||
id BIGINT(20) NOT NULL AUTO_INCREMENT,
|
||||
created TIMESTAMP NOT NULL DEFAULT 0,
|
||||
PRIMARY KEY (id)
|
||||
);
|
||||
```
|
||||
|
||||
Требуется написать запрос который вернет максимальное значение `id` и значение `created` для этого `id`:
|
||||
|
||||
```sql
|
||||
SELECT id, created FROM table where id = (SELECT MAX(id) FROM table);
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
```sql
|
||||
CREATE TABLE track_downloads (
|
||||
download_id BIGINT(20) NOT NULL AUTO_INCREMENT,
|
||||
track_id INT NOT NULL,
|
||||
user_id BIGINT(20) NOT NULL,
|
||||
download_time TIMESTAMP NOT NULL DEFAULT 0,
|
||||
PRIMARY KEY (download_id)
|
||||
);
|
||||
```
|
||||
|
||||
Напишите SQL-запрос, возвращающий все пары `(download_count, user_count)`, удовлетворяющие следующему условию: `user_count` — общее ненулевое число пользователей, сделавших ровно `download_count` скачиваний `19 ноября 2010 года`:
|
||||
|
||||
```sql
|
||||
SELECT DISTINCT download_count, COUNT(*) AS user_count
|
||||
FROM (
|
||||
SELECT COUNT(*) AS download_count
|
||||
FROM track_downloads WHERE download_time="2010-11-19"
|
||||
GROUP BY user_id)
|
||||
AS download_count
|
||||
GROUP BY download_count;
|
||||
```
|
||||
|
||||
[к оглавлению](#sql)
|
||||
|
||||
#Источники
|
||||
+ [Википедия](https://ru.wikipedia.org/wiki/SQL)
|
||||
+ [Quizful](http://www.quizful.net/interview/sql)
|
||||
|
|
@ -0,0 +1,92 @@
|
|||
[Вопросы для собеседования на Java Junior](README.md)
|
||||
|
||||
##Тестирование
|
||||
+ [Что такое _«модульное тестирование»_?](#Что-такое-модульное-тестирование)
|
||||
+ [Что такое _«интеграционное тестирование»_?](#Что-такое-интеграционное-тестирование)
|
||||
+ [Чем интеграционное тестирование отличается от модульного?](#Чем-интеграционное-тестирование-отличается-от-модульного)
|
||||
+ [Какие существуют виды тестовых объектов?](#Какие-существуют-виды-тестовых-объектов)
|
||||
+ [Чем _stub_ отличается от _mock_?](#Чем-stub-отличается-от-mock)
|
||||
+ [Что такое _«фикстуры»_?](#Что-такое-фикстуры)
|
||||
+ [Какие аннотации фикстур существуют в JUnit?](#Какие-аннотации-фикстур-существуют-в-junit)
|
||||
+ [Для чего в JUnit используется аннотация `@Ignore`?](#Для-чего-в-junit-используется-аннотация-ignore)
|
||||
|
||||
###Что такое _«модульное тестирование»_?
|
||||
__Модульное/компонентное тестирование (unit testing)__ - процесс в программировании, позволяющий проверить на корректность отдельные модули исходного кода программы. Идея состоит в том, чтобы писать тесты для каждой нетривиальной функции или метода. Это позволяет достаточно быстро проверить, не привело ли очередное изменение кода к регрессии, то есть к появлению ошибок в уже оттестированных местах программы, а также облегчает обнаружение и устранение таких ошибок.
|
||||
|
||||
Модульные тесты можно условно поделить на две группы:
|
||||
|
||||
+ _тесты состояния (state based)_, проверяющие что вызываемый метод объекта отработал корректно, проверяя состояние тестируемого объекта после вызова метода.
|
||||
|
||||
+ _тесты взаимодействия (interaction tests)_, в которых тестируемый объект производит манипуляции с другими объектами. Применяются, когда требуется удостовериться, что тестируемый объект корректно взаимодействует с другими объектами.
|
||||
|
||||
[к оглавлению](#Тестирование)
|
||||
|
||||
###Что такое _«интеграционное тестирование»_?
|
||||
__Интеграционное тестирование (integration testing)__ — это тестирование, проверяющие работоспособность двух или более модулей системы в совокупности — то есть нескольких объектов как единого блока. В тестах взаимодействия же тестируется конкретный, определенный объект и то, как именно он взаимодействует с внешними зависимостями.
|
||||
|
||||
[к оглавлению](#Тестирование)
|
||||
|
||||
###Чем интеграционное тестирование отличается от модульного?
|
||||
С технологической точки зрения интеграционное тестирование является количественным развитием модульного, поскольку так же, как и модульное тестирование, оперирует интерфейсами модулей и подсистем и требует создания тестового окружения, включая заглушки на месте отсутствующих модулей. Основная разница между модульным и интеграционным тестированием состоит в целях, то есть в типах обнаруживаемых дефектов, которые, в свою очередь, определяют стратегию выбора входных данных и методов анализа.
|
||||
|
||||
> Допустим, есть класс, который при определенных условиях взаимодействует с web-сервисом через зависимый объект. И нам надо проверить, что определенный метод зависимого объекта действительно вызывается. Если в качестве зависимого класса передать:
|
||||
|
||||
> + реальный класс, работающий с web-сервисом, то это будет интеграционное тестирование.
|
||||
|
||||
> + заглушку, то это будет тестирование состояния.
|
||||
|
||||
> + шпиона, а в конце теста проверить, что определенный метод зависимого объекта действительно был вызван, то это будет тест взаимодействия.
|
||||
|
||||
[к оглавлению](#Тестирование)
|
||||
|
||||
###Какие существуют виды тестовых объектов?
|
||||
__пустышка (dummy)__ - объект, который обычно передается в тестируемый класс в качестве параметра, но не имеет поведения: с ним ничего не происходит и никакие его методы не вызываются.
|
||||
|
||||
> Примером dummy-объектов являются new object(), null, «Ignored String» и т.д.
|
||||
|
||||
__фальшивка (fake object)__ применяется в основном для ускорения запуска ресурсоёмких тестов и является заменой тяжеловесного внешнего зависимого объекта его легковесной реализацией.
|
||||
|
||||
> Основные примеры — эмулятор базы данных (fake database) или фальшивый web-сервис.
|
||||
|
||||
__заглушка (test stub)__ используется для получения данных из внешней зависимости, подменяя её. При этом заглушка игнорирует все данные поступающие из тестируемого объекта, возвращая заранее определённый результат.
|
||||
|
||||
> Тестируемый объект использует чтение из конфигурационного файла? Тогда передаем ему заглушку `ConfigFileStub` возвращающую тестовые строки конфигурации без обращения к файловой системе.
|
||||
|
||||
__шпион (test spy)__ - разновидность заглушки, которая умеет протоколировать сделанные к ней обращения из тестируемой системы, чтобы проверить их правильность в конце теста. При этом фиксируется количество, состав и содержание параметров вызовов.
|
||||
|
||||
> Если существует необходимость проверки, что определённый метод тестируемого класса вызывался ровно 1 раз, то шпион - имменно то, что нам нужно.
|
||||
|
||||
__фикция (mock object)__ похож на _шпиона_, но обладает расширенной функциональностью, заранее заданными поведением и реакцией на вызовы.
|
||||
|
||||
[к оглавлению](#Тестирование)
|
||||
|
||||
###Чем _stub_ отличается от _mock_?
|
||||
_stub_ используется как заглушка сервисов, методов, классов и т.д. с заранее запрограммированным ответом на вызовы.
|
||||
|
||||
_mock_ использует подмену результатов вызова, проверяет сам факт взаимодействия, протоколирует и контролирует его.
|
||||
|
||||
[к оглавлению](#Тестирование)
|
||||
|
||||
###Что такое _«фикстуры»_?
|
||||
__Фикстуры (fixtures)__ - состояние среды тестирования, которое требуется для успешного выполнения теста. Основная задача фикстур заключается в подготовке тестового окружения с заранее фиксированным/известным состоянием, чтобы гарантировать повторяемость процесса тестирования.
|
||||
|
||||
[к оглавлению](#Тестирование)
|
||||
|
||||
###Какие аннотации фикстур существуют в JUnit?
|
||||
|
||||
+ `@BeforeClass` - определяет код, который должен единожды выполниться перед запуском набора тестовых методов.
|
||||
+ `@AfterClass` - код, выполняемый один раз после исполнения набора тестовых методово.
|
||||
+ `@Before` - определяет код, который должен выполняться каждый раз перд запуском любого тестовым методом.
|
||||
+ `@After` - код, выполняемый каждый раз после исполнения любого тестового метода.
|
||||
|
||||
[к оглавлению](#Тестирование)
|
||||
|
||||
###Для чего в JUnit используется аннотация `@Ignore`?
|
||||
`@Ignore` указывает JUnit на необходимость пропустить данный тестовый метод.
|
||||
|
||||
[к оглавлению](#Тестирование)
|
||||
|
||||
##Источники
|
||||
+ [Википедия](https://ru.wikipedia.org/wiki/Тестирование_программного_обеспечения)
|
||||
+ [Хабрахабр](https://habrahabr.ru/post/116372/)
|
||||
+ [Интуит](http://www.intuit.ru/department/se/testing/5/2.html)
|
||||
|
|
@ -0,0 +1,109 @@
|
|||
[Вопросы для собеседования на Java Junior](README.md)
|
||||
|
||||
##UML
|
||||
+ [Что такое _UML_?](#Что-такое-uml)
|
||||
+ [Что такое _«диаграмма»_, _«нотация»_ и _«метамодель»_ в UML?](#Что-такое-диаграмма-нотация-и-метамодель-в-uml)
|
||||
+ [Какие существуют типы диаграмм?](#Какие-существуют-типы-диаграмм)
|
||||
+ [Какие виды отношений существуют в структурной диаграмме классов?](#Какие-виды-отношений-существуют-в-структурной-диаграмме-классов)
|
||||
|
||||
###Что такое _UML_?
|
||||
__UML__ – это унифицированный графический язык моделирования для описания, визуализации, проектирования и документирования объектно-ориентированных систем. UML призван поддерживать процесс моделирования на основе объектно-ориентированного подхода, организовывать взаимосвязь концептуальных и программных понятий, отражать проблемы масштабирования сложных систем.
|
||||
|
||||
Отличительной особенностью UML является то, что словарь этого языка образуют графические элементы. Каждому графическому символу соответствует конкретная семантика, поэтому модель, созданная одним человеком, может однозначно быть понята другим человеком или программным средством, интерпретирующим UML. Отсюда, в частности, следует, что модель системы, представленная на UML, может автоматически быть переведена на объектно-ориентированный язык программирования, то есть, при наличии хорошего инструментального средства визуального моделирования, поддерживающего UML, построив модель, мы получим и заготовку программного кода, соответствующего этой модели.
|
||||
|
||||
[к оглавлению](#uml)
|
||||
|
||||
###Что такое _«диаграмма»_, _«нотация»_ и _«метамодель»_ в UML?
|
||||
__Диаграмма__ - графическое представление совокупности элементов модели в форме связного графа, вершинам и ребрам (дугам) которого приписывается определенная семантика
|
||||
|
||||
__Нотация__ – совокупность символов и правила их применения, используются для представления понятий и связей между ними.
|
||||
Нотация диаграммы определяет способ представления, ассоциации, множественности. Причем эти понятия должны быть точно определены.
|
||||
|
||||
__Метамодель__ – диаграмма, определяющая нотацию.
|
||||
Метамодель помогает понять, что такое хорошо организованная, т.е. синтаксически правильная, модель.
|
||||
|
||||
[к оглавлению](#uml)
|
||||
|
||||
###Какие существуют типы диаграмм?
|
||||
####Структурные диаграммы:
|
||||
__классов (Class diagram)__ описывает структуру системы, демонстрирующая классы системы, их атрибуты, методы и зависимости между классами.
|
||||
|
||||
__объектов (Object diagram)__ демонстрирует полный или частичный снимок моделируемой системы в заданный момент времени. На диаграмме объектов отображаются экземпляры классов (объекты) системы с указанием текущих значений их атрибутов и связей между объектами.
|
||||
|
||||
__компонентов (Component diagram)__ показывает разбиение программной системы на структурные компоненты и связи (зависимости) между компонентами.
|
||||
|
||||
+ __развёртывания/размещения (Deployment diagram)__ служит для моделирования работающих узлов и артефактов, развёрнутых на них.
|
||||
|
||||
+ __пакетов (Package diagram)__ используется для организации элементов в группы по какому-либо признаку с целью упрощения структуры и организации работы с моделью системы.
|
||||
|
||||
+ __профилей (Profile diagram)__ действует на уровне метамодели и показывает стереотип класса или пакета.
|
||||
|
||||
+ __композитной/составной структуры (Composite structure diagram)__ демонстрирует внутреннюю структуру класса и, по возможности, взаимодействие элементов (частей) его внутренней структуры.
|
||||
|
||||
+ __кооперации (Collaboration diagram)__ показывает роли и взаимодействие классов в рамках кооперации.
|
||||
|
||||
####Диаграммы поведения:
|
||||
__деятельности (Activity diagram)__ показывает разложение некоторой деятельности на её составные части. Под деятельностью понимается спецификация исполняемого поведения в виде координированного последовательного и параллельного выполнения подчинённых элементов — вложенных видов деятельности и отдельных действий, соединённых между собой потоками, которые идут от выходов одного узла к входам другого. Диаграммы деятельности используются при моделировании бизнес-процессов, технологических процессов, последовательных и параллельных вычислений.
|
||||
|
||||
__состояний/автомата/конечного автомата (State Machine diagram)__ представляет конечный автомат с простыми состояниями, переходами и композитными состояниями. Конечный автомат (State machine) — спецификация последовательности состояний, через которые проходит объект или взаимодействие в ответ на события своей жизни, а также ответные действия объекта на эти события. Конечный автомат прикреплён к исходному элементу (классу, кооперации или методу) и служит для определения поведения его экземпляров.
|
||||
|
||||
__вариантов использования/прецедентов (Use case diagram)__ отражает отношения существующие между актёрами и вариантами использования. Основная задача — представлять собой единое средство, дающее возможность заказчику, конечному пользователю и разработчику совместно обсуждать функциональность и поведение системы.
|
||||
|
||||
__взаимодействия (Interaction diagram)__:
|
||||
|
||||
+ __коммуникации (Communication diagram)__ изображает взаимодействия между частями композитной структуры или ролями кооперации при этом явно указываются отношения между элементами (объектами), а время как отдельное измерение не используется (применяются порядковые номера вызовов).
|
||||
|
||||
+ __последовательности (Sequence diagram)__ показывает взаимодействия объектов, упорядоченные по времени их проявления.
|
||||
|
||||
+ __обзора взаимодействия (Interaction overview diagram)__ — разновидность диаграммы деятельности, включающая фрагменты диаграммы последовательности и конструкции потока управления.
|
||||
|
||||
+ __синхронизации (Timing diagram)__ — альтернативное представление диаграммы последовательности, явным образом показывающее изменения состояния на линии жизни с заданной шкалой времени. Может быть полезна в приложениях реального времени.
|
||||
|
||||
[к оглавлению](#uml)
|
||||
|
||||
###Какие виды отношений существуют в структурной диаграмме классов?
|
||||
####Взаимосвязи классов
|
||||
__Обобщение (Generalization)__ показывает, что один из двух связанных классов (подтип) является частной формой другого (супертипа), который называется обобщением первого. На практике это означает, что любой экземпляр подтипа является также экземпляром супертипа. Обобщение также известно как _наследование_, _«is a» взаимосвязь_ или _отношение «является»_.
|
||||
|
||||
> «Табурет» является подтипом «Мебели».
|
||||
|
||||
__Реализация (Implementation)__ — отношение между двумя элементами модели, в котором один элемент (клиент) реализует поведение, заданное другим (поставщиком). Реализация — отношение целое-часть. Поставщик, как правило является абстрактным классом или классом-интерфейсом.
|
||||
|
||||
> «Кровать» реализует поведение «Мебели для сна»
|
||||
|
||||
####Взаимосвязи объектов классов
|
||||
__Зависимость (Dependency)__ обозначает такое отношение между классами, что изменение спецификации класса-поставщика может повлиять на работу зависимого класса, но не наоборот.
|
||||
|
||||
> «Расписание занятий» имеет зависимость от «Списка предметов». При изменении списка предметов расписание занятий будет вынуждено изменится. Однако изменение расписания занятий никак не влияет на список предметов.
|
||||
|
||||
__Ассоциация (Association)__ показывает, что объекты одной сущности (класса) связаны с объектами другой сущности таким образом, что можно перемещаться от объектов одного класса к другому. Является общим случаем композиции и агрегации.
|
||||
|
||||
> «Студент» и «Университет» имеют ассоциацию т.к. студент может учиться в университете и этой ассоциации можно присвоить имя «учится в».
|
||||
|
||||
__Агрегация (Aggregation)__ — это разновидность ассоциации в отношении между целым и его частями. Как тип ассоциации агрегация может быть именованной. Одно отношение агрегации не может включать более двух классов (контейнер и содержимое). Агрегация встречается, когда один класс является коллекцией или контейнером других. Причём по умолчанию, агрегацией называют агрегацию по ссылке, то есть когда время существования содержащихся классов не зависит от времени существования содержащего их класса. Если контейнер будет уничтожен, то его содержимое — нет.
|
||||
|
||||
> «Студент» не является неотъемлемой частью «Группы», но в то же время, группа состоит из студентов, поэтому следует использовать агрегацию.
|
||||
|
||||
__Композиция (Composition)__ — более строгий вариант агрегации. Известна также как агрегация по значению. Композиция имеет жёсткую зависимость времени существования экземпляров класса контейнера и экземпляров содержащихся классов. Если контейнер будет уничтожен, то всё его содержимое будет также уничтожено.
|
||||
|
||||
> «Факультет» является частью «Университета» и факультет без университета существовать не может, следовательно здесь подходит композиция.
|
||||
|
||||
####Общие взаимосвязи
|
||||
__Зависимость__ — это слабая форма отношения использования, при котором изменение в спецификации одного влечёт за собой изменение другого, причём обратное не обязательно. Возникает, когда объект выступает, например, в форме параметра или локальной переменной. Существует несколько именованных вариантов. Зависимость может быть между экземплярами, классами или экземпляром и классом.
|
||||
|
||||
__Уточнение отношений__ имеет отношение к уровню детализации. Один пакет уточняет другой, если в нём содержатся те же самые элементы, но в более подробном представлении.
|
||||
|
||||
__Мощность/кратность/мультипликатор отношения__ означает число связей между каждым экземпляром класса (объектом) в начале линии с экземпляром класса в её конце. Различают следующие типичные случаи:
|
||||
|
||||
| нотация | объяснение | пример |
|
||||
|:----------:|:--------------------------:|:---------------------------------------------:|
|
||||
| 0..1 | Ноль или один экземпляр | кошка имеет или не имеет хозяина |
|
||||
| 1 | Обязательно один экземпляр | у кошки одна мать |
|
||||
| 0..* или * | Ноль или более экземпляров | у кошки могут быть, а может и не быть котят |
|
||||
| 1..* | Один или более экземпляров | у кошки есть хотя бы одно место, где она спит |
|
||||
|
||||
[к оглавлению](#uml)
|
||||
|
||||
##Источники
|
||||
+ [Википедия](https://ru.wikipedia.org/wiki/UML)
|
||||
+ [Информикус](http://www.informicus.ru/)
|
||||
|
|
@ -0,0 +1,326 @@
|
|||
[Вопросы для собеседования на Java Junior](README.md)
|
||||
|
||||
#Основы Web
|
||||
+ [Что такое _WWW_?](#Что-такое-www)
|
||||
+ [Что такое _W3C_?](#Что-такое-w3c)
|
||||
+ [Какие существуют уровни модели _OSI_?](#Какие-существуют-уровни-модели-osi)
|
||||
+ [Что такое _TCP/IP_?](#Что-такое-tcpip)
|
||||
+ [Что такое _UDP_?](#Что-такое-udp)
|
||||
+ [Чем отличаются _TCP_ и _UDP_?](#Чем-отличаются-tcp-и-udp)
|
||||
+ [Что такое протокол передачи данных? Какие протоколы вы знаете?](#Что-такое-протокол-передачи-данных-Какие-протоколы-вы-знаете)
|
||||
+ [Что такое _HTTP_ и _HTTPS_? Чем они отличаются?](#Что-такое-http-и-https-Чем-они-отличаются)
|
||||
+ [Что такое _FTP_?](#Что-такое-ftp)
|
||||
+ [Чем отличаются методы _GET_ и _POST_?](#Чем-отличаются-методы-get-и-post)
|
||||
+ [Что такое _MIME тип_?](#Что-такое-mime-тип)
|
||||
+ [Что такое _Web server_?](#Что-такое-web-server)
|
||||
+ [Что такое _Web application_?](#Что-такое-web-application)
|
||||
+ [Что такое _Application server_?](#Что-такое-application-server)
|
||||
+ [Чем отличаются _Web server_ и _Application server_?](#Чем-отличаются-web-server-и-application-server)
|
||||
+ [Что такое _AJAX_? Как принципиально устроена эта технология?](#Что-такое-ajax-Как-принципиально-устроена-эта-технология)
|
||||
+ [Что такое _WebSocket_?](#Что-такое-websocket)
|
||||
+ [Что такое _JSON_?](#Что-такое-json)
|
||||
+ [Что такое _JSON схема_?](#Что-такое-json-схема)
|
||||
+ [Что такое _cookies_?](#Что-такое-cookies)
|
||||
+ [Что такое _«сессия»_?](#Что-такое-сессия)
|
||||
+ [Что такое _«авторизация»_ и _«аутентификация»_? Чем они отличаются?](#Что-такое-авторизация-и-аутентификация-Чем-они-отличаются)
|
||||
|
||||
##Что такое _WWW_?
|
||||
__WWW, World Wide Web (Всемирная паутина)__ — распределённая система, предоставляющая доступ к связанным между собой документам, расположенным на различных компьютерах, подключённых к Интернету. Для обозначения этого термина также используют слово _web_.
|
||||
|
||||
[к оглавлению](#Основы-web)
|
||||
|
||||
##Что такое _W3C_?
|
||||
__W3C, World Wide Web Consortium (Консорциум Всемирной паутины)__ — организация, разрабатывающая и внедряющая технологические стандарты для WWW.
|
||||
|
||||
W3C разрабатывает для Интернета единые принципы и стандарты, называемые _«рекомендациями» (W3C Recommendations)_, которые затем внедряются производителями программ и оборудования. Таким образом достигается совместимость между программными продуктами и аппаратурой различных компаний.
|
||||
|
||||
[к оглавлению](#Основы-web)
|
||||
|
||||
##Какие существуют уровни модели _OSI_?
|
||||
| # | Уровень (layer) | Тип данных (PDU) | Функции | Примеры |
|
||||
|--:|--------------------------------------------------|:-----------------------------------------:|----------------------------------------------------------|:--------------------------:|
|
||||
| 7 | Прикладной (application) | - | Доступ к сетевым службам | HTTP, FTP |
|
||||
| 6 | Представительский (представления) (presentation) | - | Представление и шифрование данных | ASCII, JPEG |
|
||||
| 5 | Сеансовый (session) | - | Управление сеансом связи | RPC, PAP |
|
||||
| 4 | Транспортный (transport) | Сегменты(segment) / Дейтаграммы(datagram) | Прямая связь между конечными пунктами и надежность | TCP, UDP |
|
||||
| 3 | Сетевой (network) | Пакеты (packet) | Определение маршрута и логическая адресация | IP, AppleTalk |
|
||||
| 2 | Канальный (data link) | Биты (bit) / Кадры (frame) | Физическая адресация | Ethernet, IEEE 802.2, L2TP |
|
||||
| 1 | Физический (physical) | Биты (bit) | Работа со средой передачи, сигналами и двоичными данными | USB, витая пара |
|
||||
|
||||
[к оглавлению](#Основы-web)
|
||||
|
||||
##Что такое _TCP/IP_?
|
||||
__TCP/IP__ - это два основных сетевых протокола Internet. Часто это название используют и для обозначения сетей, работающих на их основе.
|
||||
|
||||
__IP (Internet Protocol)__ - маршрутизируемый протокол, отвечающий за IP-адресацию, маршрутизацию, фрагментацию и восстановление пакетов. В его задачу входит продвижение пакета между сетями – от одного маршрутизатора до другого и тех пор, пока пакет не попадет в сеть назначения. В отличие от протоколов прикладного и транспортного уровней, протокол IP разворачивается не только на хостах, но и на всех шлюзах (маршрутизаторах). Этот протокол работает без установления соединения и без гарантированной доставки.
|
||||
|
||||
В настоящее время используются следующие две версии протокола IP:
|
||||
|
||||
+ _IPv6_ — IP-адрес имеет разрядность 128 бит и записывается в виде восьми 16-битных полей, с использованием шестнадцатеричной системы счисления и с возможностью сокращения двух и более последовательных нулевых полей до `::`, например: `2001:db8:42::1337:cafe`
|
||||
+ _IPv4_ — IP-адрес имеет разрядность 32 бита и записывается в виде четырех десятичных чисел в диапазоне 0 … 255 через точку, например: `192.0.2.34`.
|
||||
|
||||
__TCP (Transfer Control Protocol)__ - протокол, обеспечивающий надежную, требующую логического соединения связь между двумя компьютерами. Отвечает за установление соединения, упорядочивание посылаемых пакетов и восстановление пакетов, потерянных в процессе передачи.
|
||||
|
||||
Стек протоколов _TCP/IP_ включает в себя четыре уровня:
|
||||
|
||||
1. _канальный уровень (link layer)_ - например Ethernet, IEEE 802.11 Wireless Ethernet, физическая среда и принципы кодирования информации
|
||||
2. _сетевой уровень (Internet layer)_ - например IP
|
||||
3. _транспортный уровень (transport layer)_ - например TCP, UDP
|
||||
4. _прикладной уровень (application layer)_ - например HTTP, FTP, DNS
|
||||
|
||||
TCP-соединение двух узлов начинается с _handshake (рукопожатия)_:
|
||||
|
||||
+ Узел _A_ посылает узлу _B_ специальный пакет `SYN` — приглашение к соединению
|
||||
+ _B_ отвечает пакетом `SYN-ACK` — согласием об установлении соединения
|
||||
+ _A_ посылает пакет `ACK` — подтверждение, что согласие получено
|
||||
|
||||
После этого _TCP соединение_ считается установленным и приложения, работающие в этих узлах, могут посылать друг другу пакеты с данными.
|
||||
|
||||
В заголовке _TCP/IP_ пакета указывается:
|
||||
|
||||
+ IP-адрес отправителя
|
||||
+ IP-адрес получателя
|
||||
+ Номер порта
|
||||
|
||||
[к оглавлению](#Основы-web)
|
||||
|
||||
##Что такое _UDP_?
|
||||
__UDP, User Datagram Protocol (Протокол пользовательских датаграмм)__ — протокол, который обеспечивает доставку без требований соединения с удаленным модулем UDP и обязательного подтверждения получения.
|
||||
|
||||
К заголовку IP-пакета UDP добавляет всего четыре поля по 2 байта каждое:
|
||||
|
||||
1. _поле порта источника (source port)_
|
||||
2. _поле порта пункта назначения (destination port)_
|
||||
3. _поле длины (length)_
|
||||
4. _поле контрольной суммы (checksum)_
|
||||
|
||||
Поля «порт источника» и «контрольная сумма» не являются обязательными для использования в IPv4. В IPv6 необязательно только поле «порт отправителя».
|
||||
|
||||
UDP используется _DNS_, _SNMP_, _DHCP_ и другими приложениями.
|
||||
|
||||
[к оглавлению](#Основы-web)
|
||||
|
||||
##Чем отличаются _TCP_ и _UDP_?
|
||||
__TCP__ — ориентированный на соединение протокол, что означает необходимость «рукопожатия» для установки соединения между двумя хостами. Как только соединение установлено, пользователи могут отправлять данные в обоих направлениях.
|
||||
|
||||
+ _Надёжность_ — TCP управляет подтверждением, повторной передачей и тайм-аутом сообщений. Производятся многочисленные попытки доставить сообщение. Если оно потеряется на пути, сервер вновь запросит потерянную часть. В TCP нет ни пропавших данных, ни (в случае многочисленных тайм-аутов) разорванных соединений.
|
||||
+ _Упорядоченность_ — если два сообщения последовательно отправлены, первое сообщение достигнет приложения-получателя первым. Если участки данных приходят в неверном порядке, TCP отправляет неупорядоченные данные в буфер до тех пор, пока все данные не могут быть упорядочены и переданы приложению.
|
||||
+ _Тяжеловесность_ — TCP необходимо три пакета для установки соединения перед тем, как отправить данные. TCP следит за надёжностью и перегрузками.
|
||||
+ _Потоковость_ — данные читаются как поток байтов, не передается никаких особых обозначений для границ сообщения или сегментов.
|
||||
|
||||
__UDP__ — более простой, основанный на сообщениях протокол без установления соединения. Протоколы такого типа не устанавливают выделенного соединения между двумя хостами. Связь достигается путём передачи информации в одном направлении от источника к получателю без проверки готовности или состояния получателя.
|
||||
|
||||
+ _Ненадёжность_ — когда сообщение посылается, неизвестно, достигнет ли оно своего назначения — оно может потеряться по пути. Нет таких понятий как подтверждение, повторная передача, тайм-аут.
|
||||
+ _Неупорядоченность_ — если два сообщения отправлены одному получателю, то порядок их достижения цели не может быть предугадан.
|
||||
+ _Легковесность_ — никакого упорядочивания сообщений, никакого отслеживания соединений и т. д. Это лишь транспортный уровень.
|
||||
+ _Датаграммы_ — пакеты посылаются по отдельности и проверяются на целостность только если они прибыли. Пакеты имеют определенные границы, которые соблюдаются после получения, то есть операция чтения на получателе выдаст сообщение таким, каким оно было изначально послано.
|
||||
+ _Отсутствие контроля перегрузок_ — для приложений с большой пропускной способностью существует шанс вызвать коллапс перегрузок, если только они не реализуют меры контроля на прикладном уровне.
|
||||
|
||||
[к оглавлению](#Основы-web)
|
||||
|
||||
##Что такое протокол передачи данных? Какие протоколы вы знаете?
|
||||
__Протокол передачи данных__ — набор соглашений интерфейса логического уровня, которые определяют обмен данными между различными программами. Эти соглашения задают единообразный способ передачи сообщений и обработки ошибок при взаимодействии программного обеспечения разнесённой в пространстве аппаратуры, соединённой тем или иным интерфейсом.
|
||||
|
||||
Наиболее известные протоколы передачи данных:
|
||||
|
||||
+ HTTP (Hyper Text Transfer Protocol)
|
||||
+ FTP (File Transfer Protocol)
|
||||
+ POP3 (Post Office Protocol)
|
||||
+ SMTP (Simple Mail Transfer Protocol)
|
||||
+ TELNET (TErminaL NETwork)
|
||||
|
||||
[к оглавлению](#Основы-web)
|
||||
|
||||
##Что такое _HTTP_ и _HTTPS_? Чем они отличаются?
|
||||
__HTTP, HyperText Transfer Protocol (Протокол передачи гипертекста)__ — протокол прикладного уровня передачи данных.
|
||||
|
||||
Основой HTTP является технология «клиент-сервер»:
|
||||
|
||||
+ _Потребители (клиенты)_, которые инициируют соединение и посылают запрос;
|
||||
+ _Поставщики (серверы)_, которые ожидают соединения для получения запроса, производят необходимые действия и возвращают обратно сообщение с результатом.
|
||||
|
||||
Для идентификации ресурсов HTTP использует глобальные URI.
|
||||
|
||||
HTTP не сохраняет своего состояния. Это означает отсутствие сохранения промежуточного состояния между парами «запрос-ответ».
|
||||
|
||||
Структура протокола:
|
||||
|
||||
1. _Стартовая строка (starting line)_ — определяет тип сообщения;
|
||||
2. _Заголовки (headers)_ — характеризуют тело сообщения, параметры передачи и прочие сведения;
|
||||
3. _Тело сообщения (message body)_ — непосредственно данные сообщения. Обязательно должно отделяться от заголовков пустой строкой.
|
||||
|
||||
Заголовки и тело сообщения могут отсутствовать, но стартовая строка является обязательным элементом, так как указывает на тип запроса/ответа.
|
||||
|
||||
__HTTPS, HyperText Transfer Protocol Secure__ — расширение протокола HTTP, поддерживающее шифрование. Данные, передаваемые по протоколу HTTPS, «упаковываются» в криптографический протокол SSL или TLS, что обеспечивает защиту от атак, основанных на прослушивании сетевого соединения (при условии, что будут использоваться шифрующие средства и сертификат сервера проверен и ему доверяют).
|
||||
|
||||
__Различия _HTTP_ и _HTTPS___:
|
||||
|
||||
+ HTTPS является расширением HTTP.
|
||||
|
||||
+ HTTP использует не зашифрованное соединение. Соединение по HTTPS поддерживает шифрование.
|
||||
|
||||
+ Работа по HTTP быстрей и менее ресурсоёмко, т.к. шифрование HTTPS требует дополнительных затрат.
|
||||
|
||||
+ Порты по умолчанию: в случае HTTP это TCP-порт `80`, для HTTPS - TCP-порт `443`.
|
||||
|
||||
[к оглавлению](#Основы-web)
|
||||
|
||||
##Что такое _FTP_?
|
||||
__FTP, File Transfer Protocol (Протокол передачи файлов)__ — протокол передачи файлов между компьютерами в сети TCP. С его помощью можно подключаться к FTP-серверам, просматривать содержимое их каталогов и загружать файлы с сервера или на сервер. Протокол построен на архитектуре «клиент-сервер» и использует разные сетевые соединения для передачи команд и данных между клиентом и сервером.
|
||||
|
||||
По умолчанию использует TCP-порт `21`.
|
||||
|
||||
[к оглавлению](#Основы-web)
|
||||
|
||||
##Чем отличаются методы _GET_ и _POST_?
|
||||
__GET__ передает данные серверу используя URL, тогда как __POST__ передает данные, используя тело HTTP запроса. Длина URL ограничена 1024 символами, это и будет верхним ограничением для данных, которые можно отослать через GET. POST может отправлять гораздо большие объемы данных. Лимит устанавливается web-server и составляет обычно около 2 Mb.
|
||||
|
||||
Передача данных методом POST более безопасна, чем методом GET, так как секретные данные (например пароль) не отображаются напрямую в web-клиенте пользователя, в отличии от URL, который виден почти всегда. Иногда это преимущество превращается в недостатком - вы не сможете послать данные за кого-то другого.
|
||||
|
||||
[к оглавлению](#Основы-web)
|
||||
|
||||
##Что такое _MIME тип_?
|
||||
__MIME, Multipurpose Internet Mail Extension (Многоцелевые расширения Интернет-почты)__ — спецификация для передачи по сети файлов различного типа: изображений, музыки, текстов, видео, архивов и др. В HTML указание MIME-типа используется при передаче данных форм и вставки на страницу различных объектов.
|
||||
|
||||
[к оглавлению](#Основы-web)
|
||||
|
||||
##Что такое _Web server_?
|
||||
__Web server (Веб-сервер)__ — сервер, принимающий HTTP-запросы от клиентов и выдающий им HTTP-ответы. Так называют как программное обеспечение, выполняющее функции web-сервера, так и непосредственно компьютер, на котором это программное обеспечение работает.
|
||||
|
||||
Web-серверы могут иметь различные дополнительные функции, например:
|
||||
|
||||
+ автоматизация работы web-страниц;
|
||||
+ ведение журнала обращений пользователей к ресурсам;
|
||||
+ аутентификация и авторизация пользователей;
|
||||
+ поддержка динамически генерируемых страниц;
|
||||
+ поддержка HTTPS для защищённых соединений с клиентами.
|
||||
|
||||
Наиболее известные web-серверы:
|
||||
|
||||
+ Apache
|
||||
+ Microsoft IIS
|
||||
+ nginx
|
||||
|
||||
[к оглавлению](#Основы-web)
|
||||
|
||||
##Что такое _Web application_?
|
||||
__Web application (Веб-приложение)__ - клиент-серверное приложение, в котором клиентом выступает браузер, а сервером — web-сервер. Логика web application распределена между сервером и клиентом, хранение данных осуществляется, преимущественно, на сервере, а обмен информацией происходит по сети. Одним из преимуществ такого подхода является тот факт, что клиенты не зависят от конкретной операционной системы пользователя, поэтому web application является кроссплатформенным сервисом.
|
||||
|
||||
[к оглавлению](#Основы-web)
|
||||
|
||||
##Что такое _Application server_?
|
||||
__Application Server (Сервер приложений)__ — программа, представляющая собой сервер, который занимается системной поддержкой приложений и обеспечивает их жизненный цикл в соответствии с правилами, определёнными в спецификациях. Может работать как полноценный самостоятельный web-сервер или быть поставщиком страниц для другого web-сервера. Обеспечивает обмен данными между приложениями и клиентами, берёт на себя выполнение таких функций, как создание программной среды для функционирующего приложения, идентификацию и авторизацию клиентов, организацию сессии для каждого из них.
|
||||
|
||||
Наиболее известные серверы приложений Java:
|
||||
|
||||
+ Apache Tomcat
|
||||
+ Jetty
|
||||
+ JBoss
|
||||
+ GlassFish
|
||||
+ IBM WebSphere
|
||||
+ Oracle Weblogic
|
||||
|
||||
[к оглавлению](#Основы-web)
|
||||
|
||||
##Чем отличаются _Web server_ и _Application server_?
|
||||
Понятие web server относится скорее к способу передачи данных (конкретно, по протоколу HTTP), в то время как понятие Application server относится к способу выполнения этих самых приложений (конкретно, удаленная обработка запросов клиентов при помощи каких-то программ, размещенных на сервере). Эти понятия нельзя ставить в один ряд. Они обозначают разные признаки программы. Какие-то программы удовлетворяют только одному признаку, какие-то - нескольким сразу.
|
||||
|
||||
Apache Tomcat умеет выполнять приложения? Да, значит он является application server. Apache Tomcat умеет отдавать данные по HTTP? - Да. Следовательно он является web server.
|
||||
|
||||
Возьмите какую-нибудь базу данных, в которой на хранимых процедурах описана сложная логика и можно в ответ на SQL-запросы отправлять даже sms. Такую базу данных можно назвать application server, но web server - уже нет, потому что все это не работает с клиентом по HTTP протоколу.
|
||||
|
||||
Возьмите чистый Apache, в котором не включены никакие модули для поддержки языков программирования. Он умеет отдавать только статичные файлы и картинки по протоколу HTTP. Это web server, но не application server. Включите модуль для поддержки PHP и разместите там программу на PHP, которая делает запросы к базе данных и динамически формирует страницы. Теперь Apache стал и application server.
|
||||
|
||||
[к оглавлению](#Основы-web)
|
||||
|
||||
##Что такое _AJAX_? Как принципиально устроена эта технология?
|
||||
__AJAX, Asynchronous Javascript and XML (Асинхронный Javascript и XML)__ — подход к построению интерактивных пользовательских интерфейсов web-приложений, заключающийся в «фоновом» обмене данными браузера и web-сервера. В результате, при обновлении данных web-страница не перезагружается полностью и web-приложения становятся быстрее и удобнее.
|
||||
|
||||
При использовании AJAX:
|
||||
|
||||
1. Пользователь заходит на web-страницу и взаимодействует с каким-нибудь её элементом.
|
||||
2. Скрипт на языке JavaScript определяет, какая информация необходима для обновления страницы.
|
||||
3. Браузер отправляет соответствующий запрос на web-сервер.
|
||||
4. Web-сервер возвращает только ту часть документа, на которую пришёл запрос.
|
||||
5. Скрипт вносит изменения с учётом полученной информации (без полной перезагрузки страницы).
|
||||
|
||||
AJAX базируется на двух основных принципах:
|
||||
|
||||
1. использование технологии динамического обращения к серверу «на лету» (без перезагрузки страницы полностью) через динамическое создание:
|
||||
+ _дочерних фреймов_;
|
||||
+ _тега `<script>`_;
|
||||
+ _тега `<img>`_.
|
||||
2. использование _DHTML_ для динамического изменения содержания страницы;
|
||||
|
||||
AJAX не является самостоятельной технологией, это концепция использования нескольких смежных технологий:
|
||||
|
||||
+ _(X)HTML_, _CSS_ для подачи и стилизации информации;
|
||||
+ _DOM-модель_, операции над которой производятся Javascript на стороне клиента, для обеспечения динамического отображения и взаимодействия с информацией;
|
||||
+ _XMLHttpRequest_ или другой транспорт (_IFrame_, _SCRIPT-тег_, _..._) для асинхронного обмена данными с web-сервером;
|
||||
+ _JSON_ или любой другой подходящий формат (_форматированный HTML_, _текст_, _XML_, _..._) для обмена данными.
|
||||
|
||||
[к оглавлению](#Основы-web)
|
||||
|
||||
##Что такое _WebSocket_?
|
||||
__WebSocket__ — протокол полнодуплексной связи поверх TCP-соединения, предназначенный для обмена сообщениями между браузером и web-сервером в режиме реального времени.
|
||||
|
||||
Протокол _WebSocket_ определяет две URI схемы
|
||||
|
||||
+ `ws:` - нешифрованное соединение
|
||||
+ `wss:` - шифрованное соединение
|
||||
|
||||
[к оглавлению](#Основы-web)
|
||||
|
||||
##Что такое _JSON_?
|
||||
__JSON, JavaScript Object Notation__ — текстовый формат обмена данными, основанный на JavaScript.
|
||||
|
||||
JSON представляет собой (в закодированном виде) одну из двух структур:
|
||||
|
||||
+ _Набор пар «ключ:значение»_;
|
||||
+ _Упорядоченный набор значений_.
|
||||
|
||||
Ключом может быть только строка (регистрозависимая: имена с буквами в разных регистрах считаются разными).
|
||||
|
||||
В качестве значений могут быть использованы:
|
||||
|
||||
+ _Объект_ — неупорядоченное множество пар «ключ:значение», заключённое в фигурные скобки `{ }`. Ключ описывается строкой, между ним и значением стоит символ `:`. Пары ключ-значение отделяются друг от друга запятыми;
|
||||
+ _Массив (одномерный)_ — упорядоченное множество значений. Массив заключается в квадратные скобки `[ ]`. Значения разделяются запятыми.
|
||||
+ _Число_;
|
||||
+ _Литералы_ `true`, `false` и `null`;
|
||||
+ _Строка_ — упорядоченное множество из нуля или более символов Unicode, заключенное в кавычки `" "`. Символы могут быть указаны с использованием escape-последовательностей, начинающихся с обратной косой черты `\`, или записаны шестнадцатеричным кодом в кодировке UTF-8 в виде `\uFFFF`.
|
||||
|
||||
[к оглавлению](#Основы-web)
|
||||
|
||||
##Что такое _JSON схема_?
|
||||
__JSON Schema__ — один из языков описания структуры JSON-документа, используя синтаксис JSON.
|
||||
|
||||
Это самоописательный язык: при его использовании для обработки данных и описания их допустимости могут использоваться одни и те же инструменты сериализации/десериализации.
|
||||
|
||||
[к оглавлению](#Основы-web)
|
||||
|
||||
##Что такое _cookies_?
|
||||
__Сookies («куки»)__ — небольшой фрагмент данных, отправленный web-сервером и хранимый на устройстве пользователя. Всякий раз при попытке открыть страницу сайта, web-клиент пересылает соответствующие этому сайту cookies web-серверу в составе HTTP-запроса. Применяется для сохранения данных на стороне пользователя и на практике обычно используется для:
|
||||
|
||||
+ аутентификации пользователя;
|
||||
+ хранения персональных предпочтений и настроек пользователя;
|
||||
+ отслеживания состояния сеанса доступа пользователя;
|
||||
+ ведения разнообразной статистики.
|
||||
|
||||
[к оглавлению](#Основы-web)
|
||||
|
||||
##Что такое _«сессия»_?
|
||||
__Сессия__ – промежуток времени между первым и последним запросами, которые пользователь отправляет со своего устройства на сервер сайта. Завершается сессия в случае, если со стороны пользователя не поступало запросов в течение определенного промежутка времени или же при обрыве связи.
|
||||
|
||||
[к оглавлению](#Основы-web)
|
||||
|
||||
##Что такое _«авторизация»_ и _«аутентификация»_? Чем они отличаются?
|
||||
__Аутентификация__ - это проверка соответствия субъекта и того, за кого он пытается себя выдать, с помощью некой уникальной информации (отпечатки пальцев, цвет радужки, голос и тд.), в простейшем случае - с помощью имени входа и пароля.
|
||||
|
||||
__Авторизация__ - это проверка и определение полномочий на выполнение некоторых действий (например, чтение файла) в соответствии с ранее выполненной аутентификацией.
|
||||
|
||||
Очевидно, что это разные понятия, но при этом без первого не может быть второго и наоборот. То есть имея разрешение на работу, вы не сможете оказаться на рабочем месте без предъявления пропуска, равно как и нет смысла в демонстрации пропуска, если вы не планируете работать. Именно тот факт, что одного не бывает без другого, и вызывает у людей заблуждение, что это одно и то же.
|
||||
|
||||
[к оглавлению](#Основы-web)
|
||||
|
||||
#Источники
|
||||
+ [Википедия](https://ru.wikipedia.org/)
|
||||
|
|
@ -0,0 +1,189 @@
|
|||
[Вопросы для собеседования на Java Junior](README.md)
|
||||
|
||||
#XML
|
||||
+ [Что такое _XML_?](#Что-такое-xml)
|
||||
+ [Что такое _DTD_?](#Что-такое-dtd)
|
||||
+ [Чем _well-formed XML_ отличается от _valid XML_?](#Чем-well-formed-xml-отличается-от-valid-xml)
|
||||
+ [Что такое «_пространство имен_» в XML?](#Что-такое-пространство-имен-в-xml)
|
||||
+ [Что такое XSD? В чём его преимущества перед XML DTD?](#Что-такое-xsd-В-чём-его-преимущества-перед-xml-dtd)
|
||||
+ [Какие типы существуют в XSD?](#Какие-типы-существуют-в-xsd)
|
||||
+ [Какие вы знаете методы чтения XML? Опишите сильные и слабые стороны каждого метода.](#Какие-вы-знаете-методы-чтения-xml-Опишите-сильные-и-слабые-стороны-каждого-метода)
|
||||
+ [Когда следует использовать _DOM_, а когда _SAX_, _StAX_ анализаторы?](#Когда-следует-использовать-dom-а-когда-sax-stax-анализаторы)?
|
||||
+ [Какие вы знаете способы записи XML?](#Какие-вы-знаете-способы-записи-xml)
|
||||
+ [Что такое _JAXP_?](#Что-такое-jaxp)
|
||||
+ [Что такое _XSLT_?](#Что-такое-xslt)
|
||||
|
||||
##Что такое _XML_?
|
||||
__XML, eXtensible Markup Language (расширяемый язык разметки)__ - язык с простым формальным синтаксисом, хорошо приспособленный для создания и обработки документов программами и одновременно удобный для чтения и создания документов человеком.
|
||||
|
||||
XML расширяем, он не фиксирует разметку, используемую в документах и разработчик волен создавать разметку в соответствии с потребностями конкретной области, будучи ограниченным лишь синтаксическими правилами языка.
|
||||
|
||||
[к оглавлению](#xml)
|
||||
|
||||
##Что такое _DTD_?
|
||||
__DTD, Document Type Definition (определение типа документа)__ — это заранее определённый свод правил, задающий связи между элементами и атрибутами.
|
||||
|
||||
> Например, DTD для HTML гласит, что тэг `DIV` должен быть внутри тэга `BODY` и может встречаться многократно, `TITLE` — в `HEAD` и всего один раз, а `SCRIPT` – и там, и там сколь угодно раз.
|
||||
|
||||
DTD обычно описывается непосредственно в документе в виде строки-формулировки, начинающейся с `<!DOCTYPE ... >` или отдельном файле.
|
||||
|
||||
[к оглавлению](#xml)
|
||||
|
||||
##Чем _well-formed XML_ отличается от _valid XML_?
|
||||
В зависимости от уровня соответствия стандартам документ может быть «well-formed» («правильно построенный»), либо «valid» («действительный»).
|
||||
|
||||
Основные признаки _well-formed XML_ следуют из формального описания стандарта:
|
||||
|
||||
+ Документ имеет ровно один корневой элемент, в котором лежат все остальные. То есть, `<document>...</document><appendix>...</appendix>` - это не XML-документ.
|
||||
+ Все открытые теги обязаны быть закрыты. HTML, например, допускает не закрывать многие теги (`<p>`, `<body>`, `<li>`, `<td>` и многие другие). В XML так делать нельзя.
|
||||
+ Для одиночных тегов (типа `<br>`) , чтобы отличать их от открывающих, предусмотрена специальная запись: `<br/>`. Но можно написать и полностью `<br></br>`.
|
||||
+ Имена тегов регистрозависимые. Если вы открываете тег `<SiteDescription>`, то его надо закрывать именно таким же, `</sitedescription>` не допускается.
|
||||
+ Теги не могут нарушать вложенность. Вот такого не должно быть: `<em><b>...</em></b>`.
|
||||
+ Все атрибуты тегов обязаны быть заключены в двойные кавычки (`"`).
|
||||
+ Есть три символа - `<`, `>` и `&`, которые обязаны быть экранированы везде с помощью `<`, `>` и `&`. Внутри атрибутов надо экранировать еще и двойную кавычку с помощью `"`.
|
||||
+ Все символы в документе обязаны соответствовать заявленной кодировке.
|
||||
|
||||
Документ является _valid_, если он сформирован с соблюдением всех синтаксических правил корректности конкретного XML, т.е. соответствует _DTD_.
|
||||
|
||||
__*well-formed XML* - корректен синтаксически (может быть разобран парсером), а _valid XML_ - корректен как синтаксически так и семантически (удовлетворяет правилам заранее описанных словаря и грамматики (DTD)).__
|
||||
|
||||
[к оглавлению](#xml)
|
||||
|
||||
##Что такое «_пространство имен_» в XML?
|
||||
__Пространство имён XML (XML namespace)__ - это идентифицируемая с помощью ссылки URI коллекция имен, используемых в XML документах для обозначения типов элементов и именования атрибутов. Пространство имен XML отличается от тех «пространств имен», которые обычно используются в компьютерных дисциплинах, тем, что в варианте для XML оно имеет внутреннюю структуру, и, с математической точки зрения, набором не является.
|
||||
|
||||
> Пространства имён объявляются с помощью XML атрибута `xmlns`, значением которого должен быть _URI_ и префикса, однозначно идентифицирующего пространство имён каждого элемента.
|
||||
|
||||
Все имена элементов в пределах пространства имён должны быть уникальны.
|
||||
|
||||
В общем случае пространство имён XML не требует, чтобы был определён его словарь.
|
||||
|
||||
XML-документ может содержать имена элементов и атрибутов из нескольких словарей XML. В каждом словаре задано своё пространство имён — так разрешается проблема неоднозначности имён элементов и атрибутов.
|
||||
|
||||
[к оглавлению](#xml)
|
||||
|
||||
##Что такое XSD? В чём его преимущества перед XML DTD?
|
||||
__XSD, XML Schema Definition, XML Schema (XML схема)__ — язык описания структуры XML-документа. В частности, XML Schema описывает:
|
||||
|
||||
+ _словарь_ - имена элементов и атрибутов;
|
||||
+ _модель содержания_ - взаимосвязи между элементами и атрибутами, а также их
|
||||
+ _структуру_ документа;
|
||||
+ используемые _типы данных_.
|
||||
|
||||
__Преимущества XSD перед DTD__ заключаются в следующем:
|
||||
|
||||
+ DTD, в отличии от XSD, не является XML и имеет свой собственный синтаксис. В связи с этим могут возникать разнообразные проблемы с кодировкой и верификацией XML-документов.
|
||||
|
||||
+ При использовании XSD XML-парсер может проверить не только правильность синтаксиса XML документа, но также его структуру, модель содержания и типы данных. В XML DTD существует лишь один тип данных – строка и если, например, в числовом поле будет текст, то документ всё же сможет пройти верификацию, так как XML DTD не сможет проверить тип данных.
|
||||
|
||||
+ Нельзя поставить в соответствие одному XML документу больше одного DTD. А следовательно и верифицировать документ можно лишь одним DTD описанием. XSD расширяем, и позволяет подключать несколько словарей для описания типовых задач.
|
||||
|
||||
+ XSD обладает встроенными средствами документирования, позволяющими создавать самодостаточные документы, не требующие дополнительного описания.
|
||||
|
||||
[к оглавлению](#xml)
|
||||
|
||||
##Какие типы существуют в XSD?
|
||||
__Простой тип__ - это определение типа для значения, которое может использоваться в качестве содержимого элемента или атрибута. Этот тип данных не может содержать элементы или иметь атрибуты.
|
||||
|
||||
```xsd
|
||||
<xsd:element name='price' type='xsd:decimal'/>
|
||||
...
|
||||
<price>45.50</price>
|
||||
```
|
||||
|
||||
__Сложный тип__ - это определение типа для элементов, которые могут содержать атрибуты и другие элементы.
|
||||
|
||||
```xsd
|
||||
<xsd:element name='price'>
|
||||
<xsd:complexType base='xsd:decimal'>
|
||||
<xsd:attribute name='currency' type='xsd:string'/>
|
||||
</xsd:complexType>
|
||||
</xsd:element>
|
||||
...
|
||||
<price currency='US'>45.50</price>
|
||||
```
|
||||
[к оглавлению](#xml)
|
||||
|
||||
##Какие вы знаете методы чтения XML? Опишите сильные и слабые стороны каждого метода.
|
||||
__DOM (Document Object Model)__ - _объектный_ - считывает XML, воссоздавая его в памяти в виде объектной структуры при этом XML документ представляется в виде набора тегов – узлов. Каждый узел может иметь неограниченное количество дочерних узлов. Каждый дочерний тоже может содержать несколько уровней потомков или не содержать их вовсе. Таким образом в итоге получается некое дерево.
|
||||
|
||||
> ➖ Низкая скорость работы.
|
||||
|
||||
> ➖ Расходует много памяти.
|
||||
|
||||
> ➕ Прост в программировании.
|
||||
|
||||
> ➕ Если в XML много объектов с перекрёстными ссылками друг на друга, достаточно дважды пройтись по документу: первый раз создать объекты без ссылок и заполнить словарь «название-объект», второй раз — восстановить ссылки.
|
||||
|
||||
> ➕ При ошибке в XML в памяти остаётся полусозданная структура XML, которая будет автоматически уничтожена.
|
||||
|
||||
> ➕ Пригоден как для чтения так и для записи.
|
||||
|
||||
__SAX (Simple API for XML)__ _событийный_ - читает XML документ, реагируя на появляющиеся события (открывающий или закрывающий тег, строку, атрибут) вызовом предоставляемых приложением обработчиков событий. При этом, в отличии от DOM, не сохраняет документ в памяти.
|
||||
|
||||
> ➕ Высокая скорость работы
|
||||
|
||||
> ➕ Расходует мало памяти.
|
||||
|
||||
> ➗ Довольно сложен в программировании.
|
||||
|
||||
> ➖ Если в XML много объектов с перекрёстными ссылками друг на друга, надо организовать временное хранение строковых ссылок, чтобы потом, когда документ будет считан, преобразовать в указатели.
|
||||
|
||||
> ➖ При ошибке в XML в памяти остаётся полусозданная структура предметной отрасли; программист должен своими руками корректно уничтожить её.
|
||||
|
||||
> ➖ Пригоден только для чтения.
|
||||
|
||||
__StAX (Stream API for XML)__ _потоковый_ - состоящий из двух наборов API для обработки XML, которые обеспечивают разные уровни абстракции. API с использованием курсора позволяет приложениям работать с XML как с потоком лексем (или событий); приложение может проверить статус анализатора и получить информацию о последней проанализированной лексеме, а затем перейти к следующей. Второй, высокоуровневый API, использующий итераторы событий, позволяет приложению обрабатывать XML как серию объектов событий, каждый из которых взаимодействует с фрагментом XML-структуры приложения. Всё, что требуется от приложения - это определить тип синтаксически разобранного события, отнести его к соответствующему конкретному типу и использовать соответствующие методы для получения информации, относящейся к событию.
|
||||
|
||||
> ➗ Сохраняет преимущества, которые есть в SAX по сравнению с DOM.
|
||||
|
||||
> ➕ Не основан на обратных вызовах обработчиков, приложению не придется обслуживать эмулированное состояние анализатора, как это происходит при использовании SAX.
|
||||
|
||||
> ➖ Пригоден только для чтения.
|
||||
|
||||
[к оглавлению](#xml)
|
||||
|
||||
##Когда следует использовать _DOM_, а когда _SAX_, _StAX_ анализаторы?
|
||||
|
||||
DOM - естественный выбор, когда объектом предметной области является сам XML: когда нужно знать и иметь возможность изменять структуру документа, а также в случае многократного использования информации из документа.
|
||||
|
||||
Для быстрого одноразового чтения оптимальным является использование SAX или StAX.
|
||||
|
||||
[к оглавлению](#xml)
|
||||
|
||||
##Какие вы знаете способы записи XML?
|
||||
|
||||
__Прямая запись__ - пишет XML тег за тегом, атрибут за атрибутом.
|
||||
|
||||
> ➕ Высокая скорость работы.
|
||||
|
||||
> ➕ Экономия памяти: при использовании не создаётся промежуточных объектов.
|
||||
|
||||
> ➖ Пригоден только для записи.
|
||||
|
||||
__Запись DOM (Document Object Model)__ - создаёт полную структуру XML и только потом записывает её.
|
||||
|
||||
> ➖ Низкая скорость работы.
|
||||
|
||||
> ➖ Не оптимальный расход памяти.
|
||||
|
||||
> ➕ Пригоден как для записи так и для чтения.
|
||||
|
||||
[к оглавлению](#xml)
|
||||
|
||||
##Что такое _JAXP_?
|
||||
__JAXP, The Java API for XML Processing (Java API для обработки XML)__ — набор API, упрощающих обработку XML данных в программах написанных на Java. Содержит реализации DOM, SAX и StAX парсеров, поддерживает XSLT и возможность работать с DTD.
|
||||
|
||||
[к оглавлению](#xml)
|
||||
|
||||
##Что такое _XSLT_?
|
||||
__XSLT, eXtensible Stylesheet Language Transformations__ — язык преобразования XML-документов.
|
||||
|
||||
XSLT создавался для применения в _XSL (eXtensible Stylesheet Language)_ - языке стилей для XML. Во время XSL-преобразования XSLT-процессор считывает XML-документ и таблицу(ы) стилей XSLT. На основе инструкций, которые процессор находит в таблице(ах) стилей XSLT, он вырабатывает новый XML-документ или его фрагмент.
|
||||
|
||||
[к оглавлению](#xml)
|
||||
|
||||
#Источники
|
||||
+ [Википедия](https://ru.wikipedia.org/wiki/XML)
|
||||
+ [CIT Forum](http://citforum.ru/internet/xnamsps/index.shtml#ns-decl)
|
||||
+ [Quizful](http://www.quizful.net/interview/java/xml-and-parsers)
|
||||
Loading…
Reference in New Issue