Учебник по Скала

Что такое Скала?

масштаб Scala — это статически типизированный язык программирования, который сочетает объектно-ориентированное и функциональное программирование для повышения масштабируемости приложений. Scala работает преимущественно на платформе JVM, и разработчики также могут использовать его для написания программного обеспечения для нативных платформ с помощью Scala-Native или для браузера с помощью ScalaJs и других библиотек. JavaСценарий время выполнения.

Scala — это масштабируемый язык, используемый для разработки программного обеспечения для различных платформ, именно поэтому он и получил своё название. Язык был разработан для решения ряда проблем, связанных с избыточностью кода, встречающихся в Scala. Java при этом оставаясь лаконичным. Мартин Одерски разработал Scala, и первый публичный релиз состоялся в 2004 году.

Зачем изучать Scala

Вот основные причины для изучения языка программирования Scala:

• Scala легко освоить программистам, работающим с объектно-ориентированным программированием. Java Он стал одним из популярных языков программирования для разработчиков и разработчиков, и в последние годы его популярность значительно возросла.
• Scala предоставляет пользователям первоклассные функции.
• Scala может быть выполнена на JVM, что открывает путь к совместимости с другими языками.
• Он разработан для параллельных, распределенных и отказоустойчивых приложений, работающих на основе обмена сообщениями, что делает его одним из самых востребованных языков программирования этого десятилетия.
• Это лаконичный, мощный язык, который может быстро развиваться в соответствии с потребностями своих пользователей.
• Это объектно-ориентированный язык, включающий в себя множество функций функционального программирования, что предоставляет разработчикам большую гибкость в написании кода.
• Scala предлагает Duck Typing посредством структурных типов.
• В нём меньше стандартного текста, чем в других подобных приложениях. Java.
• Фреймворки Lift и Play, написанные на Scala, продолжают развиваться и набирать популярность.

Как установить Скалу

Для начала написания программ на Scala вам необходимо установить эту программу на свой компьютер. Для этого посетите официальный сайт по адресу: https://www.scala-lang.org/download/ Чтобы скачать последнюю версию Scala.

Перейдя по ссылке, вы увидите два варианта установки Scala. В этом уроке по Scala мы будем использовать... IntelliJ IDEA, которая обеспечивает превосходную поддержку Scala «из коробки».

Перейдя по ссылке для скачивания, вы найдете две версии интегрированной среды разработки IntelliJ.

Для этого урока по Scala мы скачаем Community Edition, которая является бесплатной и включает в себя все необходимое для написания программ на Scala.

Шаг 1) Выберите Community Edition.
На странице нажмите на выпадающее меню «Community Edition».

Предлагается возможность загрузки IDE IntelliJ вместе с JBR, который содержит реализацию JDK.Java Комплект разработчика (Development Kit), например OpenJDK, необходимый Scala для компиляции и выполнения кода.

Шаг 2) Запустите установку.
После загрузки IntelliJ дважды щелкните по установщику и следуйте инструкциям мастера установки на экране.

Шаг 3) Выберите место.
Выберите место для установки IDE.

Если вы не загрузили пакет с JDK, установщик все равно предложит вам добавить JDK, поставив галочку в соответствующем поле во время установки.

Шаг 4) Нажмите "Далее.
Оставьте остальные параметры по умолчанию без изменений и нажмите «Далее».

Программа Scala Hello World

Шаг 5) Нажмите на значок запуска.
После завершения установки запустите среду разработки IntelliJ, щелкнув по ее значку автозапуска в меню «Пуск», как обычное приложение.

Вам все еще нужно добавить плагин Scala в IntelliJ. Щелкните раскрывающееся меню в правом нижнем углу экрана и выберите пункт «Плагины».

На вкладке «Маркетплейс» найдите плагин Scala. Он появится в качестве первого результата в разделе «Языки».

Шаг 6) Установите плагин.
Нажмите «Установить», чтобы начать загрузку плагина Scala.

Шаг 7) Перезапустите IDE.
После завершения загрузки вам будет предложено перезапустить IDE, чтобы установленный плагин мог начать работу.

После перезапуска вы вернетесь на ту же страницу, что и раньше, но теперь плагин Scala установлен и готов к работе.

Шаг 8) Выберите «Создать проект», после чего откроется страница, где вы сможете выбрать язык для проекта.

Шаг 9) Выберите Scala, поставив галочку в поле Scala, и нажмите «Далее».

Шаг 10) Выберите место для сохранения файла проекта и дайте проекту имя.

Если каталог не существует, IntelliJ запросит разрешение на его создание. Примите запрос и нажмите «Готово». После этого вы перейдете к своему проекту Scala, который в данный момент не содержит кода Scala.

Загрузка индексов занимает некоторое время, поэтому не беспокойтесь, если вы не можете взаимодействовать с IDE, пока внизу отображается индикатор выполнения. IDE загружает файлы, необходимые для запуска Scala и обеспечения автозавершения кода.

Шаг 11) Щелкните вкладку «Проект» в левой части IDE и разверните ее, чтобы увидеть содержимое проекта.

На данном этапе проект пуст и содержит только папку .idea и файл hello-world.iml, сгенерированный IDE. Интерес представляет папка src, содержащая исходный код проекта. Именно здесь вы создаёте свой первый файл Scala.

Шаг 12) Щелкните правой кнопкой мыши на src, чтобы открыть меню и создать новый файл Scala.

Выберите имя для файла. В этом руководстве по Scala используйте... ЗдравствуйтеЗатем выберите «Объект» из выпадающего списка в качестве типа содержимого файла Scala.

После этого у вас будет файл Scala, содержащий объект-синглтон, который вы будете использовать для выполнения кода.

Теперь, когда у вас есть файл Scala с объектом Hello, напишите свою первую программу, расширив созданный вами объект с помощью ключевого слова App.

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

Внутри объекта Hello напишите функцию println() для вывода текста на консоль. Запустите программу, нажав на зеленую стрелку.

Нажатие на стрелку открывает опцию «Запустить Hello». Выбор этой опции компилирует код, и через несколько секунд вывод программы появляется в консоли IntelliJ.

Вы успешно установили Scala и запустили свою первую программу.

Что вы можете сделать с помощью Scala

Scala широко используется во многих областях благодаря своей гибкости и совместимости с JVM. Типичные примеры использования включают:

• Разработка веб-интерфейсов с использованием ScalaJS.
• Разработка мобильных приложений для Android и iOS с использованием Scala Native.
• Серверные библиотеки, такие как HTTP4S, Akka-Http и Play Framework.
• Приложения Интернета вещей (IoT).
• Разработка игр.
• Обработка естественного языка с использованием набора библиотек ScalaNLP.
• Совместное применение передовых методов, таких как функциональное программирование и объектно-ориентированное программирование.
• Высокопроизводительные приложения для обмена данными с использованием акторов — библиотека для JVM, созданная по образцу Erlang.
• Машинное обучение с использованием библиотек, таких как Figaro для вероятностного программирования и Apache. Spark для крупномасштабной обработки данных.

Анонимные функции

Язык Scala поддерживает анонимные функции, также называемые функциональные литералыПоскольку Scala — функциональный язык, разработчики часто разбивают большие задачи на множество мелких и создают множество функций. Чтобы упростить этот процесс, Scala позволяет создавать функции. создан без имениВы можете присваивать их непосредственно переменным или определениям, используя defкак показано в следующем примере на Scala:

val multiplyByTwo = (n:Int) => n * 2
def multiplyByThree = (n:Int) => n * 3

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

multiplyByTwo(3)
//6

multiplyByThree(4)
//12

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

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

val sayHello = () => { println("hello") }

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

Например, метод filter принимает встроенную функцию для создания другой коллекции, содержащей только те элементы, которые соответствуют критериям, определенным в анонимной функции.

val myList = List(1,2,3,4,5,6,7)

val myEvenList = myList.filter((n: Int) => n % 2 == 0)
//List(2,4,6)

val myOddList = myList.filter((n:Int) => n % 2 != 0)
//List(1,3,5,7)

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

//the one checking that the value is even
(n: Int) => n % 2 == 0

//the one checking that the value is odd
(n:Int) => n % 2 != 0

В Scala также можно использовать подстановочные знаки (*) в тех случаях, когда параметр анонимной функции не имеет имени. Например:

var timesTwo = (_:Int) * 2

timesTwo(5)
//10

В этом случае вы не указываете имя параметра. Для его обозначения используется символ подчеркивания.

Ленивая оценка

В большинстве языков программирования переменные и параметры функций вычисляются последовательно, одна за другой. В Scala используется ключевое слово `value`. lazy помогает работать со значениями, которые вы не хотите оценивать до тех пор, пока на них не будет дана ссылка.

Переменная, помеченная как «ленивая», не вычисляется в месте своего определения, что обычно называется «немедленным вычислением». Она вычисляется только при последующем обращении к ней в коде.

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

lazy val myExpensiveValue = expensiveComputation

def runMethod() = {
    if(settings == true) {
        use(myExpensiveValue)
    } else {
        use(otherValue)
    }
}

Это не единственный вариант использования ленивых переменных. Они также помогают справляться с циклическими зависимостями в коде.

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

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

def sometimesUsedString(someValue:String, defaultValue: => String) = {
 if(someValue != null) {
   use(defaultValue)
 } else {
   use(someValue)
   }
 }

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

Вывод типа

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

var first:String = "Hello, "
var second:String = "World"
var third = first + second
//the compiler infers that third is of type String

Функция высшего порядка

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

def doMathToInt(n:Int, myMathFunction:Int=>Int): Int = {
    myMathFunction(n)
}

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

Подпись () => Int Это означает, что функция принимает на вход ничего и возвращает целое число (Int). Примером такой функции является функция, генерирующая случайное целое число.

def generateRandomInt() = {
 return scala.util.Random.nextInt()
}

Указанная выше функция имеет сигнатуру. () => Int.

Функция также может иметь сигнатуру. () => UnitЭто означает, что функция ничего не принимает на вход и не возвращает тип. Вместо этого функция может изменить какое-либо состояние или выполнить предопределенное действие.

Подобные методы не рекомендуются, поскольку они могут действовать как «чёрный ящик», влияя на систему неизвестным образом. Кроме того, их сложнее тестировать. Явное указание типов входных и выходных данных позволяет понять, что делает ваша функция.

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

def powerByFunction(n:Int): Int=>Int = {
  return (x:Int) => scala.math.pow(x,n).toInt
}

Приведённая выше функция принимает тип Int. Тип возвращаемого значения — анонимная функция, принимающая тип Int. x и использует его в качестве аргумента для степенной функции.

Карринг

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

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

def multiplyTwoNumbers(n:Int)(m:Int): Int = {
  return n * m
}

Если вам нужна функция, которая умножает на определенное число, вам не нужно создавать еще один метод умножения. Вы можете передать один аргумент каррированной функции и повторно использовать результат:

def multiplyTwoNumbers(n:Int)(m:Int): Int = {
  return n * m
}

var multiplyByFive = multiplyTwoNumbers(5) _

multiplyByFive(4)

//returns 20

Соответствие шаблону

В Scala есть мощный встроенный механизм, который помогает проверить, соответствует ли переменная определенным критериям, подобно оператору switch. Java или цепочку операторов if/else. Язык поддерживает сопоставление с образцом, которое можно использовать для проверки того, является ли переменная определенного типа. Сопоставление с образцом в Scala — мощный инструмент, позволяющий деструктурировать компоненты, имеющие определенный тип. unapply Метод для получения необходимых полей непосредственно из сопоставляемой переменной.

В Scala сопоставление с образцом также обеспечивает более удобный синтаксис, чем оператор switch.

myItem match {
  case true => //do something
  case false => //do something else
  case  _ => //if none of the above do this by default
}

Вы сравниваете переменную с набором вариантов. Когда переменная соответствует критериям, выражение справа от жирной стрелки (=>) вычисляется и возвращает результат совпадения.

Подчеркивание позволяет выявить случаи, которые не соответствуют условиям кода, имитируя поведение варианта по умолчанию в операторе switch.

class Animal(var legs:Int, var sound:String)
class Furniture(var legs:Int, var color:Int, var woodType:String)

myItem match {
case myItem:Animal => //do something
case myItem:Furniture => //do something else
case _ => //unknown type, do something else
}

В приведенном выше коде можно определить тип myItem переменная и, исходя из нее, перейти к конкретному коду.

Проверка соответствия шаблону проверяет, соответствует ли переменная каждому случаю в порядке его следования.

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

• Проверить, есть ли myItem is true и выполнить логику справа от толстой стрелки «=>».
• Используйте символ подчеркивания для сопоставления всего, что не соответствует ни одному из операторов case, определенных в коде.

С помощью case-классов вы можете деструктурировать класс, например...tract-поля внутри объекта.

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

неизменность

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

Переменная, определенная с помощью val Ключевое слово является только для чтения, тогда как ключевое слово, определенное с помощью var Эти данные могут быть прочитаны и изменены позже другими функциями или пользователем в коде.

var changeableVariable = 8

changeableVariable = 10
//the compiler does not complain, and the code compiles successfully

println(changeableVariable)
//10

val myNumber = 7

myNumber = 4

//this will not compile

Попытка присвоить значение myNumber после объявления его как val Вызывает ошибку компиляции: «переназначение значению val».

Зачем использовать неизменяемость?

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

Классы и объекты

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

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

Вот класс под названием Rectangle, который имеет два значения и две функции. Вы также можете использовать параметры. l и b непосредственно в качестве полей в программе. У вас есть объект, который имеет метод main и создает экземпляр класса с двумя значениями.

Это критически важно для анализа и выбора наиболее эффективных ключевых слов для улучшения рейтинга вашего сайта.

class Rectangle(l: Int, b: Int) {
  val length: Int = l
  val breadth: Int = b
  def getArea: Int = l * b
  override def toString = s"This is a rectangle with length $length and breadth $breadth"
}
object RectObject {
  def main(args: Array[String]) {
    val rect = new Rectangle(4, 5)
    println(rect.toString)
    println(rect.getArea)
  }
}

В Scala все поля и методы по умолчанию являются публичными. Крайне важно использовать override потому что toString Это уже определено для каждого объекта в Scala.

наследование

В Scala существует несколько типов наследования (одноуровневое, многоуровневое, множественное, иерархическое и гибридное), которые имеют много общего с традиционными формами, встречающимися в... JavaНаследование возможно как от классов, так и от трейтов. Для наследования членов одного класса в другой класс используется ключевое слово `add`. extendsЭто обеспечивает возможность повторного использования.

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

В приведенном ниже примере на Scala базовым классом является Circleа производный класс — SphereОкружность имеет значение, называемое радиусом, которое наследуется от класса Sphere. Метод calcArea переопределяется с помощью ключевого слова override.

Это критически важно для анализа и выбора наиболее эффективных ключевых слов для улучшения рейтинга вашего сайта.

class Circle {
  val radius = 5
  def calcArea = {
    println(radius * radius)
  }
}
class Sphere extends Circle {
 override def calcArea = {
    println(radius * radius * radius)
  }
}
  object SphereObject {
    def main(args : Array[String]) {
      new Sphere().calcArea
    }
  }

Abstracпроизводство

В Scala можно создать абсtract-методы и поля элементов с использованием абс.tracклассы и характеристики. Внутри абсtracВ классах и характеристиках можно определить абстракции.tracполя t без их реализации.

Это критически важно для анализа и выбора наиболее эффективных ключевых слов для улучшения рейтинга вашего сайта.

trait MakesSound {
    var nameOfSound:String
    def sound():String
}
abstract class HasLegs(var legs:Int) {
    val creatureName:String

    def printLegs():String = {
        return s"$creatureName has this number of legs: $legs"
    }
}

Эти поля реализуются классами, которые наследуют трейт или абстракцию.tracкласс. Вы можете использовать трейты для создания конструкций.tracСначала определите, что должно делать приложение, а затем реализуйте эти методы.

trait DatabaseService {
    def addItemName(itemName:String)
    def removeItem(itemId:Int)
    def updateItem(itemId:Int, newItemName:String)
}

Таким образом, вы можете спланировать внешний вид приложения, не реализуя соответствующие методы.ping Вы представляете, как будут выглядеть различные методы. Это следует схеме, известной как программирование для абсолютного результата.tracречь идет скорее о вопросах, чем о фактической реализации.

Занятие, начинающееся со слов: abstract ключевое слово может содержать оба вариантаtracт и неабсtract методов. Однако множественное наследование не поддерживается в абс.tracклассы t, поэтому вы можете расширить только один абсtracкласс Т.

Одноэлементные объекты

Синглтон — это класс, который создается только один раз в программе. Он происходит из популярного и полезного шаблона программирования, известного как «шаблон синглтона». Он полезен для создания экземпляров, предназначенных для длительного существования и частого доступа в программе, где состояние является неотъемлемой частью координации событий в системе. Создать такой класс в Scala легко, поскольку Scala предоставляет простой способ создания синглтонов с помощью... object ключевое слово.

object UserProfile {
    var userName = ""
    var isLoggedIn:Boolean = false
}

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

def getLoggedInStatus():Boolean = {
   return UserProfile.isLoggedIn
}

def changeLoggedInStatus():Boolean = {
    UserProfile.isLoggedIn = !UserProfile.isLoggedIn
    return UserProfile.isLoggedIn
}

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

Неявные классы

Неявные классы — это функция, добавленная в версии 2.10, и используются в основном для добавления новой функциональности к существующим закрытым классам.

implicit Ключевое слово должно быть определено в классе, объекте или трейте. Основной конструктор неявного класса должен иметь ровно один аргумент в списке первых параметров. Он также может включать дополнительный список неявных параметров.

В приведенном ниже примере на Scala добавлена ​​новая функция для замены гласных в строке на символ *.

object StringUtil {
  implicit class StringEnhancer(str: String) {

    def replaceVowelWithStar: String = str.replaceAll("[aeiou]", "*")
  }
}

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

import StringUtil.StringEnhancer

object ImplicitEx extends App {
  val msg = "This is Guru99!"
  println(msg.replaceVowelWithStar)
}

Объектно-ориентированное программирование (ООП) против функционального программирования (ФП)

В объектно-ориентированном программировании программы создаются группами.ping Данные и функции, работающие с этими данными, объединены в тесно связанные блоки. Объекты хранят свои данные в полях, а методы работают с ними. В этом стиле программирования основная абстракцияtracРечь идёт о данных, поскольку создаваемые методы предназначены для работы с этими данными.

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

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

Важные фреймворки на Scala

Вот несколько важных фреймворков для Scala:

• Играть это платформа веб-приложений с открытым исходным кодом, которая использует Архитектура MVCВыпущенный в 2007 году и теперь распространяемый под лицензией Apache, к 2013 году он стал одним из самых популярных фреймворков на GitHub. Его используют такие компании, как LinkedIn, WalmartSamsung и Eero используют эту платформу.
• Подъемник Foursquare — ещё один бесплатный веб-фреймворк, написанный на Scala и запущенный в 2007 году. Foursquare использует фреймворк Lift. Это высокопроизводительный фреймворк, с которым быстро разрабатывать приложения.
• Акка Предоставляет набор инструментов для создания высокопроизводительных, распределенных и отказоустойчивых приложений, работающих с обменом сообщениями, на платформе JVM.
• Кошки - Leecork Это библиотека, которая предоставляет аббревиатуры.tracции для функционального программирования.
• Spark Это унифицированный аналитический механизм для обработки больших объемов данных, широко используемый в рабочих процессах обработки больших данных и машинного обучения.

Поддержка параллелизма

• В Scala значения по умолчанию являются неизменяемыми, что делает язык очень адаптивным для параллельных сред.
• Scala обладает множеством функций, которые делают её идеальным инструментом для параллельного выполнения приложений.
• Фьючерсы и промисы упрощают асинхронную обработку данных, тем самым поддерживая параллелизм.
• Akka — это инструментарий, использующий модель параллельного выполнения Actor. Акторы выполняют действия, когда получают сообщения.
• Параллелизм с использованием потоков из Java Эта функция также поддерживается в Scala.
• Потоковая обработка — еще одна замечательная функция, позволяющая осуществлять непрерывную обработку данных в режиме реального времени.

Scala имеет одни из лучших библиотек параллелизма в мире. Java экосистема:

• Родной Java потоки.
• Волокна из таких библиотек, как Vertx.
• ZIO — это библиотека, содержащая примитивы, помогающие работать с параллельными и асинхронными вычислениями.
• Программная транзакционная память (STM) для транзакций.
• Функция Future, встроенная в язык Scala.

Java против Скалы

Вот основные различия между Java и Скала.

Часто задаваемые вопросы (FAQ)