Вопросы на собеседовании по Scala

Учебники
Scala

Перед прочтением этого поста, пожалуйста, просмотрите мой предыдущий пост по адресу «Scala Basic Interview Questions and Answers», чтобы получить базовые знания о языке Scala. В этом посте мы собираемся обсудить некоторые дополнительные вопросы по собеседованию по Scala, которые могут быть полезны опытным разработчикам Scala. Примечание:- Поскольку этот список уже стал очень большим, я собираюсь опубликовать еще один пост с оставшимися вопросами и ответами. Пожалуйста, обратитесь к этому посту по адресу: «Scala Intermediate and Advanced Interview Questions and Answers»

Вопросы собеседования по Scala

В этом разделе мы собираемся перечислить все вопросы собеседования по Scala среднего уровня, а затем обсудим их подробно в следующем разделе.

  1. Что такое основной конструктор? Что такое вторичный или вспомогательный конструктор в Scala?
  2. Для чего используются вспомогательные конструкторы в Scala? Пожалуйста, объясните правила их определения в Scala?
  3. Каковы различия между Array и ArrayBuffer в Scala?
  4. Что такое case class? Что такое case object? Каковы преимущества case class?
  5. В чем разница между Case Object и Object (обычным объектом)?
  6. Когда сравнивается с обычным классом, каковы основные преимущества или польза Case-класса?
  7. Каково использование методов isInstanceOf и asInstanceOf в Scala? Существует ли в Java что-то подобное?
  8. Как вы доказываете, что по умолчанию Case Object сериализуем, а обычный объект – нет?
  9. В чем разница между Array и List в Scala?
  10. В чем разница между “val” и “lazy val” в Scala? Что такое Eager Evaluation? Что такое Lazy Evaluation?
  11. Какова связь между методом equals и == в Scala? В чем разница между == в Scala и == в Java?
  12. Разница между Inner class в Scala и Inner class в Java?
  13. Что такое Diamond Problem? Как Scala решает проблему Diamond?
  14. Почему у Scala нет ключевого слова “static”? Какова основная причина такого решения?
  15. Какова цель ключевого слова “object” в Scala? Как создать Singleton объекты в Scala?
  16. Как определить фабричные методы, используя ключевое слово “object” в Scala? Какова цель определения фабричных методов в объекте?
  17. Что такое метод apply в Scala? Что такое метод unapply в Scala? В чем разница между методами apply и unapply в Scala?
  18. Как это работает внутри, когда мы создаем экземпляр класса без использования ключевого слова ‘new’ в Scala? Когда следует выбирать этот подход?
  19. Как объявить частный основной конструктор в Scala? Как вызвать частный основной конструктор в Scala?
  20. Доступ объекта-спутника к закрытым членам своего класса-спутника в Scala?
  21. Основное проектировочное решение относительно двух отдельных ключевых слов: class и object в Scala? Как определяются члены экземпляра и статические члены в Scala?
  22. Что такое объект в Scala? Это объект-одиночка или экземпляр класса?
  23. Что такое сопутствующий объект в Scala? Что такое сопутствующий класс в Scala? Каково назначение сопутствующего объекта в Scala?
  24. Как реализовать интерфейсы в Scala?
  25. Что такое Range в Scala? Как создать Range в Scala?
  26. Сколько значений типа Nothing существует в Scala?
  27. Сколько значений типа Unit существует в Scala?
  28. Что такое Range в Scala? Как создать Range в Scala?
  29. В ФП, в чем разница между функцией и процедурой?
  30. Какие основные различия между вспомогательными конструкторами Scala и конструкторами Java?
  31. Для чего используется ключевое слово ‘yield’ в конструкции for-выражения Scala?
  32. Что такое guard в конструкции for-выражения Scala?
  33. Как Scala автоматически и легко решает проблему бриллианта наследования по сравнению с Java 8?
  34. В Scala Pattern Matching следует какому шаблону проектирования? В Java оператор ‘instanceof’ следует какому шаблону проектирования?

Вопросы и ответы на интервью по Scala

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

Что такое основной конструктор? Что такое вторичный или вспомогательный конструктор в Scala? Какова цель вспомогательного конструктора в Scala? Возможно ли перегрузить конструкторы в Scala?

В Scala существует два вида конструкторов:

  • Основной конструктор
  • Вспомогательный конструктор

Основной конструктор В Scala основной конструктор – это конструктор, который определяется вместе с определением класса. У каждого класса должен быть один основной конструктор: либо конструктор с параметрами, либо конструктор без параметров. Пример: –

class Person

Above Person class имеет один нулевой параметр или без параметра или безпараметричный основной конструктор для создания экземпляров этого класса.

class Person (firstName: String, lastName: String)

Above Person class имеет два параметра основного конструктора для создания экземпляров этого класса. Вспомогательный конструктор Вспомогательный конструктор также известен как Вторичный конструктор. Мы можем объявить Вторичный конструктор, используя ключевые слова ‘def’ и ‘this’, как показано ниже:

class Person (firstName: String, middleName:String, lastName: String){
  def this(firstName: String, lastName: String){
      this(firstName, "", lastName)
  }
}

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

В Scala основная цель Вспомогательных конструкторов – это перегрузка конструкторов. Как и в Java, мы можем предоставить различные виды конструкторов, чтобы пользователь мог выбрать подходящий в зависимости от своих требований. Правила Вспомогательных конструкторов:

  • Они похожи на методы. Как и в методах, мы должны использовать ключевое слово ‘def’ для их определения.
  • Мы должны использовать одно и то же имя ‘this’ для всех Вспомогательных конструкторов.
  • Каждый Вспомогательный конструктор должен начинаться с вызова ранее определенного другого Вспомогательного конструктора или основного конструктора. В противном случае – ошибка времени компиляции.
  • Каждый вспомогательный конструктор должен отличаться своим списком параметров: может быть по количеству или типам.
  • Вспомогательные конструкторы не могут вызывать конструкторы суперкласса. Они должны вызывать их только через первичный конструктор.
  • Все вспомогательные конструкторы вызывают свой первичный конструктор либо напрямую, либо косвенно через другие вспомогательные конструкторы.

ПРИМЕЧАНИЕ:- Если вы хотите узнать о конструкторах Scala, пожалуйста, обратитесь к моим сообщениям Scala на: Первичный конструктор и Вспомогательный конструктор.

Какие различия между Array и ArrayBuffer в Scala?

Различия между Array и ArrayBuffer в Scala:

  • Array – это массив фиксированного размера. Мы не можем изменить его размер после создания.
  • ArrayBuffer – это массив переменного размера. Он может увеличивать или уменьшать свой размер динамически.
  • Array похож на примитивные массивы Java.
  • ArrayBuffer похож на ArrayList в Java.

Что такое case class? Что такое case object? Каковы преимущества case class?

Case class – это класс, который определяется с ключевыми словами “case class”. Case object – это объект, который определяется с ключевыми словами “case object”. Благодаря ключевому слову “case”, мы получаем некоторые преимущества, избегая шаблонного кода. Мы можем создавать объекты case class без использования ключевого слова “new”. По умолчанию компилятор Scala добавляет префикс “val” для всех параметров конструктора. Поэтому без использования val или var параметры конструктора Case class становятся членами класса, что невозможно для обычных классов. Преимущества case class:

  • По умолчанию компилятор Scala добавляет методы toString, hashCode и equals. Мы можем избежать написания этого шаблонного кода.
  • По умолчанию компилятор Scala добавляет объект-компаньон с методами apply и unapply, поэтому нам не нужно использовать ключевое слово new для создания экземпляров case class.
  • По умолчанию компилятор Scala также добавляет метод copy.
  • Мы можем использовать case class в сопоставлении с образцом.
  • По умолчанию case class и Case Objects являются сериализуемыми.

В чем разница между объектом Case и объектом (Обычным объектом)?

  • Обычный объект создается с использованием ключевого слова “object”. По умолчанию это синглтон-объект.
object MyNormalObject
  • Объект Case создается с использованием ключевого слова “case object”. По умолчанию это также синглтон-объект
case object MyCaseObject
  • По умолчанию объект Case получает методы toString и hashCode. Но обычный объект этого не делает.
  • По умолчанию объект Case сериализуем. Но обычный объект – нет.

По сравнению с обычным классом, каковы основные преимущества или польза от Case-класса?

Вот основные преимущества или польза от Case-класса по сравнению с обычными классами:

  • Избегает множества шаблонного кода, добавляя некоторые полезные методы автоматически.
  • По умолчанию поддерживает неизменяемость, потому что его параметры – ‘val’
  • Легко использовать в сопоставлении с образцом.
  • Не нужно использовать ключевое слово ‘new’ для создания экземпляра Case-класса.
  • По умолчанию поддерживает сериализацию и десериализацию.

Каково использование методов isInstanceOf и asInstanceOf в Scala? Существует ли в Java что-то подобное?

Оба метода isInstanceOf и asInstanceOf определены в классе Any. Поэтому нет необходимости импортировать их в любой класс или объект. Метод “isInstanceOf” используется для проверки, является ли объект заданного типа или нет. В случае успеха возвращает true, в противном случае возвращает false.

   scala> val str = "Hello"
   
   scala>str.isInstanceOf[String]
   res0: Boolean = false

Метод “asInstanceOf” используется для приведения объекта к заданному типу. Если заданный объект и тип совпадают, то он приводится к указанному типу. В противном случае генерируется исключение java.lang.ClassCastException.

 scala> val str = "Hello".asInstanceOf[String]
 str: String = Hello

В Java ключевое слово ‘instanceof’ аналогично методу ‘isInstanceOf’ в Scala. В Java следующий тип ручного приведения подобен методу ‘asInstanceOf’ в Scala.

AccountService service = (AccountService)
 context.getBean("accountService");

Как вы доказываете, что по умолчанию Case Object сериализуем, а Normal Object – нет?

Да, по умолчанию объект Case сериализуем. Но обычный объект – нет. Мы можем это доказать, используя метод isInstanceOf, как показано ниже:

scala> object MyNormalObject
defined object MyNormalObject

scala> MyNormalObject.isInstanceOf[Serializable]
res0: Boolean = false

scala> case object MyCaseObject
defined object MyCaseObject

scala> MyCaseObject.isInstanceOf[Serializable]
res1: Boolean = true

В чем разница между массивом и списком в Scala?

  • Массивы всегда изменяемы, в то время как список всегда неизменяем.
  • После создания мы можем изменять значения массива, в то время как объект списка нельзя изменить.
  • Массивы – это структуры данных фиксированного размера, в то время как списки – переменного размера. Размер списка автоматически увеличивается или уменьшается в зависимости от операций, выполняемых над ним.
  • Массивы – инварианты, в то время как списки – коварианты.

ПРИМЕЧАНИЕ: Если вы не уверены в инварианте и коварианте, прочтите мой следующий пост по вопросам собеседования Scala.

В чем разница между “val” и “lazy val” в Scala? Что такое Eager Evaluation? Что такое Lazy Evaluation?

Как мы обсуждали в моих Основных вопросах собеседования Scala, “val” означает значение или константу, которая используется для определения неизменяемых переменных. Существует два вида оценок программы:

  • Eager Evaluation
  • Ленивая оценка

Энергичная оценка означает оценку программы на этапе компиляции или во время развертывания программы независимо от того, используют ли клиенты эту программу или нет. Ленивая оценка означает оценку программы во время выполнения по требованию, то есть когда клиенты обращаются к программе, она оценивается только в этот момент. Разница между “val” и “lazy val” заключается в том, что “val” используется для определения переменных, которые оцениваются энергично, а “lazy val” также используется для определения переменных, но они оцениваются лениво.

Какова связь между методом equals и == в Scala? Чем отличается оператор == в Scala от оператора == в Java?

В Scala нам не нужно вызывать метод equals() для сравнения двух экземпляров или объектов. Когда мы сравниваем два экземпляра с помощью ==, Scala автоматически вызывает метод equals() этого объекта. Оператор == в Java используется для проверки равенства ссылок, то есть указывают ли две ссылки на один и тот же объект или нет. Оператор == в Scala используется для проверки равенства экземпляров, то есть равны ли два экземпляра или нет.

Разница между внутренним классом Scala и внутренним классом Java?

В Java внутренний класс связан с внешним классом, то есть внутренний класс является членом внешнего класса. В отличие от Java, Scala по-разному рассматривает отношение между внешним и внутренним классом. Внутренний класс Scala связан с объектом внешнего класса.

Что такое проблема ромба (Diamond Problem)? Как Scala решает проблему ромба?

A Diamond Problem is a Multiple Inheritance problem. Some people calls this problem as Deadly Diamond Problem. In Scala, it occurs when a Class extends more than one Traits which have same method definition as shown below. Unlike Java 8, Scala solves this diamond problem automatically by following some rules defined in Language. Those rules are called “Class Linearization”. Example:-

trait A{   
  def display(){ println("From A.display")  }
}
trait B extends A{ 
  override def display() { println("From B.display") }
}
trait C extends A{ 
  override def display() { println("From C.display") }
}
class D extends B with C{ }

object ScalaDiamonProblemTest extends App {
    val d = new D
    d display
}

Здесь вывод – “From C.display” из трейта C. Компилятор Scala считывает “extends B with C” справа налево и берет определение метода “display” из самого левого трейта, то есть из C. ПРИМЕЧАНИЕ: Смотрите мой пост “Глубокое изучение Scala Traits”, чтобы узнать это с четким объяснением.

Почему у Scala НЕТ ключевого слова “static”? Какова основная причина этого решения?

Как мы знаем, у Scala вообще нет ключевого слова “static”. Это решение было принято командой Scala. Основная причина этого решения заключается в том, чтобы сделать Scala чистым объектно-ориентированным языком. Ключевое слово “static” означает, что мы можем получить доступ к членам класса без создания объекта или без использования объекта. Это полностью противоречит принципам ООП. Если язык поддерживает ключевое слово “static”, то этот язык не является чисто объектно-ориентированным. Например, так как Java поддерживает ключевое слово “static”, она не является чисто объектно-ориентированным языком. Но Scala – это чисто объектно-ориентированный язык.

Каково назначение ключевого слова “object” в Scala? Как создать одиночные объекты в Scala?

В Scala ключевое слово “object” используется для следующих целей:

  • Оно используется для создания одиночного объекта в Scala.
object MySingletonObject

Здесь MySingletonObject автоматически становится одиночным объектом. – Ключевое слово “object” используется для определения приложений Scala, которые являются исполняемыми программами Scala.

object MyScalaExecutableProgram{   
   def main(args: Array[String]){
       println("Hello World")
   }
}

Когда мы определяем метод main в объекте, как показано выше (это то же самое, что метод main() в Java), он автоматически становится исполняемой программой Scala. – Оно используется для определения статических членов, таких как статические переменные и статические методы, без использования ключевого слова “static”.

object MyScalaStaticMembers{ 
  val PI: Double = 3.1414  
  def add(a: Int, b: Int) = a + b
}

Переменная def PI и методы add станут статическими элементами. Это означает, что мы можем вызывать их без создания отдельного объекта, наподобие MyScalaStaticMembers.add(10,20).- Они используются для определения фабричных методов. Пожалуйста, ознакомьтесь с моим следующим вопросом на эту тему.

Как определить фабричные методы с использованием ключевого слова object в Scala? Зачем определять фабричные методы в объекте?

В Scala мы используем ключевое слово “object” для определения фабричных методов. Основная цель этих фабричных методов в Scala – избежать использования ключевого слова “new”. Мы можем создавать объекты без использования ключевого слова “new”. Для определения фабричных методов: Мы можем использовать метод apply для определения фабричных методов в Scala. Если у нас есть основной конструктор и несколько вспомогательных конструкторов, то нам нужно определить несколько методов apply, как показано ниже.

class Person(val firstName: String, val middleName: String, val lastName: String){
  def this(firstName: String, lastName: String){
    this(firstName,"",lastName)
  }
}
object Person{
  def apply(val firstName: String, val middleName: String, val lastName: String) 
        = new Person(firstName,middleName,lastName)

  def apply(val firstName: String, val lastName: String) 
        = new Person(firstName, lastName)
}

Теперь мы можем создавать объекты класса Person без использования ключевого слова “new” или с использованием его – на ваше усмотрение.

val p1 = new Person("Scala","Java")
or 
val p1 = Person("Scala","Java")

Что такое метод apply в Scala? Что такое метод unapply в Scala? В чем разница между методами apply и unapply в Scala?

В Scala методы apply и unapply играют очень важную роль. Они также очень полезны в Play Framework для отображения и обратного отображения данных между данными формы и данными модели. Простыми словами,

  • метод apply: Составление или сборка объекта из его компонентов.
  • метод unapply: Разложение или демонтаж объекта на его компоненты.

Метод apply в Scala: Используется для составления объекта с использованием его компонентов. Предположим, мы хотим создать объект Person, затем используем два компонента firstName и laststName и составляем объект Person, как показано ниже.

class Person(val firstName: String, val lastName: String)

object Person{
  def apply(firstName: String, lastName: String) 
        = new Person(firstName, lastName)
}

Метод unapply в Scala: Используется для разложения объекта на его компоненты. Он следует обратному процессу метода apply. Предположим, у нас есть объект Person, тогда мы можем разложить этот объект на его два компонента: firstName и laststName, как показано ниже.

class Person(val firstName: String, val lastName: String)

object Person{
  def apply(firstName: String, lastName: String) 
        = new Person(firstName, lastName)

    def unapply(p: Person): (String,String) 
        = (p.firstName, p.lastName)
}

Как это работает внутри, когда мы создаем экземпляр класса в Scala без использования ключевого слова “new”? Когда мы используем этот подход? Как объявить закрытые конструкторы в Scala?

В Scala, когда мы создаем экземпляр класса без использования ключевого слова “new”, внутренне происходит вызов соответствующего метода apply, доступного в объекте-компаньоне. Здесь подходящий метод apply означает, что он сопоставлен с параметрами. Когда мы выбираем этот вариант: Когда нам нужно предоставить закрытый конструктор и мы хотим избежать использования ключевого слова “new”, мы можем реализовать только метод apply с тем же набором параметров и позволить нашим пользователям класса создавать его без ключевого слова “new”.

Как объявить закрытый первичный конструктор в Scala? Как сделать вызов закрытого первичного конструктора в Scala?

В Scala мы можем легко объявить закрытый первичный конструктор. Просто определите первичный конструктор как обычно и добавьте “private” сразу после имени класса и перед списком параметров, как показано ниже:

class Person private (name: String)
object Person{
 def apply(name: String) = new Person(name)
}

Поскольку это закрытый конструктор, мы не можем вызывать его извне. Мы должны предоставить фабричный метод (то есть метод apply), как показано выше, и использовать этот конструктор косвенно.

Может ли объект-компаньон получить доступ к закрытым элементам своего класса-компаньона в Scala?

Обычно закрытые элементы означают доступ только в пределах этого класса. Однако в Scala класс-компаньон и объект-компаньон предоставили еще одну возможность. В Scala объект-компаньон может получить доступ к закрытым элементам своего класса-компаньона, и класс-компаньон может получить доступ к закрытым элементам своего объекта-компаньона.

Какова основная концепция проектирования относительно двух отдельных ключевых слов: class и object в Scala? Как мы определяем членов экземпляра и статических членов в Scala?

В Scala мы используем ключевое слово class для определения членов экземпляра и ключевое слово object для определения статических членов. В Scala нет ключевого слова static, но мы все равно можем его определить, используя ключевое слово object. Основное решение проектирования заключается в ясном разделении между членами экземпляра и статическими членами. Свободная связь между ними. И еще одна важная причина – избежать ключевого слова static, чтобы Scala стала языком чистого ООП.

Что такое object в Scala? Это объект-одиночка или экземпляр класса?

В отличие от Java, у Scala два значения для ‘object’. Не путайтесь, я поясню. В Java у нас есть только одно значение для ‘object’ – “Экземпляр класса”.

  • Как и в Java, первое значение для ‘object’ – “Экземпляр класса”.
val p1 = new Person("Scala","Java")
or 
val p1 = Person("Scala","Java")
  • Второй смысл заключается в том, что object – это ключевое слово в Scala. Оно используется для определения исполняемых программ Scala, объектов-компаньонов, одиночных объектов и т. д.

Что такое объект-компаньон в Scala? Что такое компаньон-класс в Scala? Для чего используется объект-компаньон в Scala?

Простыми словами, если класс Scala и объект имеют одно и то же имя и определены в одном и том же исходном файле, то этот класс известен как “компаньон-класс”, а объект – как “компаньон-объект”. Когда мы создаем класс с использованием ключевого слова Scala “class” и объект с использованием ключевого слова Scala “object” с одним и тем же именем и в том же исходном файле, этот класс известен как “компаньон-класс”, а объект – как “компаньон-объект”. Пример: – Employee.scala

class Employee{ }
object Employee{ }

В Scala основная цель объекта-компаньона – определение методов apply и избегание использования нового ключевого слова при создании экземпляра объекта этого компаньонского класса.

Как реализовать интерфейсы в Scala?

Как мы знаем из фона Java, мы используем интерфейс для определения контакта. Однако в Scala нет концепции интерфейса. Даже ключевого слова интерфейса нет. В Scala есть более мощное и гибкое понятие, а именно трейт для этой цели.

Что такое Range в Scala? Как создать Range в Scala?

Range – это ленивая коллекция в Scala. Range – это класс, доступный в пакете ‘scala’, например, ‘scala.Range’. Он используется для представления последовательности целочисленных значений. Это упорядоченная последовательность целых чисел. Пример:-

scala> 1 to 10
res0: scala.collection.immutable.Range.Inclusive = Range(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

scala> 1 until 10
res1: scala.collection.immutable.Range = Range(1, 2, 3, 4, 5, 6, 7, 8, 9)

Сколько значений типа Nothing есть в Scala?

В Scala тип Nothing не имеет значений, то есть ноль. У него нет никаких значений. Он является подтипом всех классов Value и Reference.

Сколько значений типа Unit есть в Scala?

в Scala, Unit – это что-то аналогичное ключевому слову void в Java. Он используется для представления “Нет значения”. У него есть только одно значение, которое равно ().

Что такое чистая функция?

A pure function is a function without any observable side-effects. That means it returns always same results irrespective how many times we call it with same inputs. A pure function always gives same output for the same inputs. For Example:-

scala> 10 + 20
res0: Int = 30
scala>
scala> 10 + 20
res0: Int = 30

Здесь “+” – чистая функция, доступная в классе Int. Она дает одинаковый результат 30 для одинаковых входных данных 10 и 30, независимо от того, сколько раз ее вызывают.

В ФП, в чем разница между функцией и процедурой?

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

Каковы основные различия между вспомогательными конструкторами Scala и конструкторами Java?

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

  • Вспомогательные конструкторы вызываются с использованием ключевого слова “this”.
  • Все вспомогательные конструкторы определяются с одним и тем же именем, то есть “this”. В Java мы используем имя класса для определения конструкторов.
  • Каждый вспомогательный конструктор должен начинаться с вызова ранее определенного вспомогательного конструктора или основного конструктора.
  • Мы используем ключевое слово “def” для определения вспомогательных конструкторов, как при определении метода/функции. В Java определение конструктора и определение метода отличаются.

Как использовать ключевое слово “yield” в конструкции for-comprehension Scala?

Мы можем использовать ключевое слово “yield” в конструкции for-comprehension Scala. “for/yield” используется для итерации коллекции элементов и генерации новой коллекции того же типа. Оно не изменяет исходную коллекцию. Оно генерирует новую коллекцию того же типа, что и исходный. Например, если мы используем конструкцию “for/yield” для итерации по списку, то она генерирует только новый список.

scala> val list = List(1,2,3,4,5)
list: List[Int] = List(1, 2, 3, 4, 5)

scala> for(l <- list) yield l*2
res0: List[Int] = List(2, 4, 6, 8, 10)

Что такое guard в конструкции for-comprehension в Scala?

В Scala конструкция for-comprehension имеет условие if, которое используется для записи условия фильтрации некоторых элементов и создания новой коллекции. Это условие if также известно как “Guard”. Если это условие верно, то добавляем этот элемент в новую коллекцию. В противном случае элемент не добавляется в исходную коллекцию. Пример:- Гвард for-comprehension для создания только четных чисел в новой коллекции. 

scala> val list = List(1,2,3,4,5,6,7,8,9,10)
list: List[Int] = List(1, 2, 3, 4, 5 , 6 , 7 , 8 , 9 , 10)

scala> for(l <- list if l % 2 =0 ) yield l
res0: List[Int] = List(2, 4, 6, 8, 10)

Как Scala автоматически и легко решает проблему алмазного наследования по сравнению с Java 8?

Если мы используем интерфейс Java 8 с методами по умолчанию, мы столкнемся с проблемой алмазного наследования. Разработчику придется решать ее вручную в Java 8. Она не предоставляет решения по умолчанию или автоматического разрешения этой проблемы. В Scala мы столкнемся с той же проблемой с трейтами, но Scala очень умна и автоматически решает проблему алмазного наследования с использованием концепции линеаризации классов.

На Scala, сопоставление шаблонов следует какому шаблону проектирования? В Java оператор ‘instanceof’ следует какому шаблону проектирования?

На Scala сопоставление шаблонов использует шаблон проектирования “Посетитель” (Visitor). Точно так же оператор ‘instanceof’ в Java также использует шаблон проектирования “Посетитель” (Visitor). Вот и все о “Промежуточных вопросах и ответах по Scala”. Мы обсудим некоторые расширенные вопросы и ответы по Scala в моих будущих сообщениях. Пожалуйста, оставьте комментарий, если вам понравилась моя публикация или у вас есть какие-либо проблемы/предложения.

Source:
https://www.digitalocean.com/community/tutorials/scala-interview-questions