чем scala лучше java
Чем отличаются Scala и Java?
Хочешь больше книг по программированию?
Подпишись на наш канал и ознакамливайся бесплатно!
Scala – это новое поколение виртуальной машины Java (JVM). Этот язык становится все более популярным в качестве современной альтернативы Java, — пишет KV.BY в своем переводе статьи «What Are The Differences Between Scala and Java?».
Будучи представленным еще в 1995 году, Java считался одним из бесспорных лидеров среди языков программирования, особенно в сфере программирования на стороне сервера. На сегодняшний день Scala уж точно не может похвастаться столь же высоким уровнем популярности, как у Java. Однако последние несколько лет популярность Scala неуклонно растет.
Решение Twitter в 2019 году перевести свою платформу с Ruby на Scala привлекло внимание многих компаний в мире веб-разработки. Подобная реклама сыграла свою ключевую роль, поэтому многие другие компании после этого стали переходить на Scala. Сегодня Scala используется для back-end-разработки многих веб-сайтов: eBay, Netflix, LinkedIn и The Guardian.
Все большее количество программистов переходит на Scala. Поэтому, если вы связаны с разработкой, то вам важно понимать разницу между Java и Scala, чтобы при работе над следующим проектом иметь достаточно информации и выбрать наиболее подходящий язык.
Размер и качество кода
При использовании Java разработчикам необходимо писать длинные строки кода, чтобы выполнить простые задачи. Scala позволяет выполнить те же задачи, используя более лаконичный код. Задача, которая требует 20 строк Java-кода, на Scala займет всего 6. Такое сжатие кода позволяет сделать его более организованным, а также легким для чтения и дальнейшего использования. Меньшее количество строк также облегчает нахождение и исправление багов.
Функциональная природа Scala позволяет более естественно использовать лямбда-функции и цепочки, требуя задействования меньшего количества кода.
Сложность кода
Scala использует более сложные структуры, нежели Java. Многие разработчики отмечают, что на первоначальном этапе Scala сложнее поддается изучению.
Когда дело касается использования расширенных функций в языке Scala, уровень сложности значительно повышается. Именно поэтому Scala приобрел репутацию сложного языка. Однако для тех, кто начинает изучать язык с нуля, более лаконичный Scala-код может значительно облегчить жизнь.
Функциональное программирование
Java создавался в 1990-ых годах, поэтому его формировали как объектно-ориентированный язык программирования. Однако в дальнейшем он был улучшен и получил некоторые возможности функционального программирования.
Scala был создан в начале 2000-ых изначально в качестве функционального языка программирования. В отличие от Java, у Scala более продвинутые возможности в функциональном программировании, такие как неизменность («немутабельность»), функции высокого порядка и отложенные вычисления.
Структуры
Значительную часть синтаксиса и функций Scala позаимствовал у Java. Но у Scala все же есть ряд структур, которые недоступны в Java. К примеру, Scala поддерживает case-классы и автоматический вывод типа. Высокая структурированность языка Scala позволяет программистам в дальнейшем использовать его в качестве предметно-ориентированного языка (DSL). Благодаря этому можно использовать Scala в соответствии с потребностями определенных проектов.
Совместимость
В теории, Java и Scala совместимы друг с другом. Разработчики могут вызывать Java-функции прямо внутри Scala-кода. Однако процесс внедрения Java-функций в Scala-код и наоборот не так прост, как выглядит на первый взгляд. Каждый язык по-своему реализует интерфейсы, коллекции, аннотации и иные функции. Поэтому хоть оба языка и взаимосовместимы, но эти различия все же имеют значение.
Модель параллелизма
При использовании Java 8 программисты вынуждены придерживаться классической, основанной на потоках модели параллелизма. Такой подход разбивает программу на несколько параллельно запущенных задач на стадии выполнения. Scala же использует модель акторов, которая является более современной и эффективной. Это позволяет разработчикам определять каждый объект в качестве актора с определенным поведением и почтовым адресом. Таким образом, Scala упрощает взаимодействие потоков и контроль, тем самым повышая эффективность всего процесса.
Производительность
В соответствии с тестом, проведенным новостным IT-ресурсом DZone, Scala на 20% быстрее Java. Однако стоит отметить, что оценка производительности всегда субъективна, поэтому не стоит доверять ей на 100%.
Так как оба языка работают на JVM, перед запуском их код должен одинаковым образом компилироваться в байт-код. Scala выигрывает в производительности благодаря такой технике оптимизации, как «хвостовая рекурсия» («tail call recursion»), которая выполняется на этапе компиляции, где если последним выражением в методе является рекурсивный вызов, то он может быть опущен и заменен на итерационное решение. Кроме этой оптимизации, фактически, Java и Scala обладают близкими по своим показателям характеристиками производительности, так как оба языка работают на JVM.
Кроме случаев, когда необходимо внедрять приложение реального времени, разница в производительности этих двух языков не будет играть ключевой роли. Если приложение обрабатывает сетевой трафик, http-запросы или подключается к базе данных, тогда влияние производительности языка будет незначительным.
Доступность инструментов и фреймворков
Как уже отмечалось ранее, Java – это более «взрослый» язык. Поэтому у Java-разработчиков есть более широкий выбор редакторов, фреймвороков и инструментов. И это, возможно, одно из главных преимуществ данного языка. Scala понадобятся годы, чтобы построить столь же сильное сообщество и собрать такой же архив инструментов.
Так как популярность Scala продолжает расти, регулярно выходят новые инструменты и фреймворки. Кроме того, Scala – это JVM-язык, поэтому у разработчиков на этом языке есть возможность использовать некоторые Java-библиотеки и фреймворки.
Java или Scala: какой язык выбрать?
Как итог, более сложные структуры Scala-кода и некоторые сложности в изучении этого языка уравновешиваются его лаконичностью и широкими возможностями в функциональном программировании. С другой стороны, Java является крайне распространенным решением для многих крупных компаний по всему миру и продолжает предоставлять программистам широкий выбор инструментов и фреймворков.
В целом, Java и Scala имеют много схожестей и оба могут быть использованы для создания самых различных приложений. Однако каждый из этих языков программирования имеет свои сильные и слабые стороны. Поэтому при работе над каждым проектом необходимо оценивать текущие потребности и уже, исходя из них, решать, какой язык выбрать для разработки. Scala – это отличный вариант для приложений, которые имеют дело с большими данными. Но для других проектов сложность кода и небольшое количество специалистов могут нейтрализовать все бонусы, которые может предоставить Scala.
Какой путь выбрать: Java-разработка или Scala-программирование?
У начинающего Java-программиста есть два направления для профессионального роста. Можно углубиться в Java-разработку или переключиться на функциональное программирование на языке Scala. Но что же лучше выбрать? Онлайн-школа OTUS поможет определиться с решением.
Глубоководное погружение в сервисную разработку c gRPC
gRPC — высокопроизводительный фреймворк Google, применяемый для удалённого вызова процедур (Remote procedure call, RPC). Он прост в эксплуатации, имеет встроенную поддержку для балансировки нагрузки, трассировки, аутентификации и проверки жизнеспособности сервисов. Этот фреймворк, благодаря работе поверх протокола HTTP и использованию Protocol Buffers gRPC, демонстрирует высокую скорость.
Чтобы детальнее разобраться, подключайтесь на открытый демо-урок «gRPC для микросервисов, или не REST-ом единым», который пройдёт 24 марта в 20:00 по МСК. Чтобы поучаствовать в мероприятии, нужно заранее пройти вводное тестирование. Демо-урок проводится в том же формате, что и занятия на полноценном курсе «Java Developer Professional». Вебинар позволит вам в полной мере оценить профессионализм преподавателей и эффективность обучения по авторским методикам школы.
Ведущий мероприятия — Сергей Петрелевич, сертифицированный Java-специалист, сдавший экзамены Oracle Certified Professional и Java SE 8 Programmer. Сергей посвятил 8 лет созданию банковских процессинговых систем для пластиковых карт. В копилке преподавателя работа в таких компаниях, как «Компас+», Borlas, «СМП Банк».
Функциональное программирование на языке Scala
Scala — язык, объединяющий две парадигмы: объектно-ориентированное программирование и функциональное программирование. Это и привлекает опытных разработчиков. Scala заслуженно оценили ведущие IT-корпорации мира, включая Twitter, LinkedIn и Novell. Начинающие Scala-разработчики отмечают сложность языка, поскольку думать приходится в нескольких парадигмах программирования. Но оно того стоит. По производительности Scala не уступает Java, позволяет писать приложения для Android и совместим с Java-библиотеками.
Подробнее познакомиться с языком можно на демо-уроке «Событие как основной тип данных в системе». Мероприятие состоится 25 марта в 20:00 по московскому времени. Для участия необходимо предварительно пройти тестирование. На вебинаре расскажут, какие бывают виды взаимодействия между разными частями системы, а также раскроют их плюсы и минусы. На примере конкретной задачи познакомят с архитектурой, основанной на событиях. Участники урока вместе с преподавателем решат задание и выяснят, в каких случаях полезно использовать событийно-ориентированную архитектуру.
Знакомство со Scala проведёт для слушателей Вадим Опольский — эксперт по Scala Big Data, который трудится в IT-сфере свыше 15 лет. Например, он участвовал в создании пилотного проекта, в который Facebook инвестировала 1,5 млн долларов. Вадим искренне верит, что его ученики достигнут не меньших результатов.
Выбирайте подходящий для вас вебинар и присоединяйтесь. Будет интересно и познавательно.
Русские Блоги
Подробное сравнение Scala и Java
Что такое Scala
Преимущества по сравнению с java
Элегантность: это первый вопрос, который следует рассмотреть разработчикам фреймворков: насколько элегантен API или нет, напрямую влияет на опыт программирования программиста.
Высокая скорость: язык Scala обладает сильной выразительностью, одна строка кода стоит нескольких строк Java, а скорость разработки высока; Scala компилируется статически, поэтому он намного быстрее, чем JRuby и Groovy.
Может быть интегрирован в экосистему Hadoop: теперь Hadoop является стандартом де-факто для больших данных. Spark предназначен не для замены Hadoop, а для улучшения экосистемы Hadoop. Большая часть языка JVM может думать о Java, но API, созданный Java, слишком уродлив, или слишком сложно реализовать элегантный API.
Разница с java (в качестве примеров возьмем java8 и Scala2.12)
Определить переменные
Scala использует var, и тип переменной следует
Когда java определяет переменную, тип переменной находится впереди
Новая линия
тип данных
Все типы данных в Scala являются объектами [т. Е. Измененными Object], в отличие от основных типов данных в Java. Но типы данных в Scala также делятся на два типа: AnyVal [тип значения] и AnyRef [ссылочный тип]. 
Не представляет значения, что эквивалентно void на других языках. Используется как тип результата для методов, которые не возвращают никаких результатов. Единица имеет только одно значение экземпляра, записанное как ().
Nothing
Тип Nothing находится внизу иерархии классов Scala; это подтип любого другого типа.
Класс Null имеет только один объект-экземпляр: null, который похож на ключевое слово null в Java. Любому типу AnyRef можно присвоить значение null, но AnyVal нельзя присвоить значение null.
AnyRef
В языке Java предусмотрено восемь основных типов. Шесть типов чисел (четыре целых числа, два числа с плавающей запятой), один символьный тип и один логический тип. 
Путеводитель
Scala может импортировать пакеты куда угодно, import Операторы используются для импорта членов (классов, признаков, функций и т. Д.) В другие пакеты.
По сравнению со Scala пакет руководств Java является только классом руководства и может быть объявлен только в заголовке заранее.
Оператор
возвращаемое значение
Scala
for: Scala также предоставляет множество возможностей для общей структуры цикла for, которые вызываются для понимания или для выражений.
while：Поскольку цикл while не имеет возвращаемого значения, при использовании этого оператора для вычисления и возврата результата необходимо использовать внешние переменные. Это приведет к загрязнению тела цикла внешних переменных. Поэтому, хотя в Scala это не рекомендуется, рекомендуется использовать для цикла.
break: в Scala нет ключевого слова break, и его можно реализовать с помощью объектов.
break: ключевое слово java, используемое для выхода из цикла
функция
Определить функции в Scala
Если вам не нужно передавать параметры при вызове функции, () можно опустить.
Scala определяет вариативные функции
Определить функции в java
При вызове функции, нужны ей параметры или нет, добавляйте круглые скобки
Определить функции переменных параметров в java
Сводка по функциям Scala
Функция может иметь много параметров, но если параметров нет, то при вызовеНе могу принести ()
Тип параметра и тип возвращаемого значения функции могут быть любым типом данных.
Тип возвращаемого значения функции может быть автоматически определен на основе возвращаемого значения, поэтому тип возвращаемого значения можно не указывать.
Если функция указывает ключевое слово return для возврата данных, тип возвращаемого значения не может быть пропущен
Если функция определяет тип возвращаемого значения как Unit, возвращаемое значение будет () независимо от того, есть ли ключевое слово return и какая последняя строка.
Любая грамматическая структура в грамматике Scala может содержать другие грамматические структуры. То есть классы / функции могут быть вложены в функции, а другие классы и функции также могут быть вложены в классы.
Функция может быть присвоена переменной
Функция не может быть перегружена
Сопоставление с образцом
Сопоставление с образцом с переключателем и если в java
Scala использует match и if для сопоставления с образцом, что более эффективно. Соответствие Scala также может соответствовать массивам, типам, примитивам, спискам и т. Д.
Модификатор разрешения
В Scala есть три модификатора разрешений, которые по умолчанию являются общедоступными.
Метод строительства
В Java есть конструктор параметров и конструктор без параметров, который записан в классе.
Scala делится на главный конструктор и вспомогательный конструктор. Основной метод построения записывается в теле класса, а имя вспомогательного метода построения записывается в классе.Должен быть вызван существующий вспомогательный метод построения или основной метод построения.
наследовать
Черты
В java нет характеристик, но есть интерфейсы, которые наследуются орудиями.
Черты характера в Scala наследуются с помощью расширений. 
Scala динамически подмешивается. Исходя из того, что предыдущий код не менялся, добавляйте функции напрямую, и масштабируемость очень мощная.
Неявное преобразование
Преобразование низкого уровня в высокий уровень при автоматическом преобразовании Java: неявное преобразование, преобразование высокого уровня в преобразование низкого уровня с принудительным преобразованием
В Scala, если вы хотите использовать неявное преобразование, вы должны пометить его как неявное ключевое слово
Ключевое слово implicitt может использоваться для изменения параметров [неявных значений и неявных параметров], функций [неявных представлений], классов [неявных классов], объектов [неявных объектов]
Во всей области имя неявного преобразования должно быть уникальным.
Неявное преобразование сначала ищется в его области действия.Если неявное преобразование отсутствует в текущей области, компилятор автоматически ищет неявное преобразование в сопутствующем объекте соответствующего исходного или целевого типа.
Неявные значения, неявные классы и неявные объекты в Scala часто помещаются в одноэлементные объекты.
Неявное преобразование не имеет ничего общего с именем функции или именем параметра, только сигнатура [тип параметра и тип возвращаемого значения]
Неявное преобразование может улучшить функцию класса без изменения исходного кода
задавать
Scala в основном делится на изменяемые и неизменяемые коллекции, за которыми следуют список, карта и набор. Scala определяет больше операций с коллекциями.
В Scala также существует концепция кортежей, которая эквивалентна объектному классу в Java, что более удобно и не требует определения другого класса.
Интеллектуальная рекомендация
Улучшение алгоритма обучения Blue Bridge Cup Простое добавление (насильственный подсчет)
описание проблемы Четыре натуральных числа меньше 10 могут делить 3 или 5 (3, 5, 6, 9), а их сумма равна 23. Вычислите сумму всех натуральных чисел меньше 1000, которые могут делить 3 или 5. Затем исп.
Стратегия Стратегия Pattern
совместное использование обучения awk
Простые несколько строк кода написать Sigmoid Function Image
Python Написать сигмовидное изображение функции.
Scala как расширенная Java или Java++
Java существует достаточно долго, на ней написано огромное количество софта и она является лидером в своей области. Однако Java не лишена недостатков. При проектировании языка важным критерием была простота и легкость изучения языка, и эта простота заставляет писать огромное количество лишнего кода, что бы компенсировать недостаточную гибкость языка: паттерны проектирования, XML конфиги, AOP, гетеры-сеттеры, try catch finaly синтаксис и т.д. Так же очевидно что не для всех задач чистый ООП подход является оптимальным, некоторые задачи намного эффективнее выполнять в функциональном стиле.
В разы более мощный инструментарий для разработчиков библиотек. Эффективность разработки на каком-либо языке определяется в большей степени наличием готовых библиотек. Какой толк от языка, если придется на нем придется разрабатывать все с нуля? Возможность разрабатывать свои DSL, implicit параметры и преобразования, функции высшего порядка, мощная система типов позволяют писать более гибкие и мощные библиотеки, которыми удобнее пользоваться. Но даже если на Scala еще не написана нужная вам библиотека, вы можете просто использовать библиотеку из Java.
Высокоуровневая работа с коллекциями. Благодаря наличию замыканий для большинства манипуляций с коллекциями (отфильтровать, сделать выборку, проверить все элементы на условие, разбить на группы и т.д) существуют отдельные методы. Это позволяет в 95% использовать уже готовые библиотечные методы, в то время когда на Java вам необходимо писать те же самые операции каждый раз самому.
Лаконичность динамического программирования. Благодаря implicit’ам, неявному выводу типов и богатому синтаксическому сахару ваш код начинает выглядеть почти так-же лаконично как если бы вы писали на динамическом языке типа Groovy или Ruby. При этом каждая переменная имеет свой тип и компилятор вам подскажет если вы будете делать что-то не так.
Меньшее количество неинформационного шума. Это как раз тот момент где общая картина складывается из мелочей. В Scala очень много моментов где она позволяет писать на несколько символов меньше. На выходе получается примерно в 2-3 раза меньше кода, чем на Java без потери читабельности!
Поддержка многих паттернов проектирования на уровне синтаксиса. Хотите синглетон — меняет слово «class» на «object», хотите фабрику — используйте конструктор со значениями по умолчанию и именными параметрами, хотите команду — просто передаете замыкание и т.д.
Более понятный и структурированный код бизнес-логики. Не все можно описать на высоком уровне, бывает логика с большим количеством if /else, проверок, условий, выделением дополнительных вспомогательных методов. Благодаря паттерн-матчингу, монадам, функциям высшего порядка, вложенным методам такая логика получается в разы читабельнее. Когда в Java необходимо сделать много if / else / switch проверок в Scala можно использовать паттерн матчинг, когда в Java необходимо заимплементить интерфейс и добавить класс в конфигурацию, в Scala нужно просто передать замыкание, когда в Java идут проверки на null и обработка ошибок в Scala используются монады, когда в Java создаются классы Utils, фабрики, интерфейсы с глобальными переменными, сигнглетоны в Scala создается объект-компаньен.
Blogerator.org
Эксклюзивные ИТ-новости, обзоры и интервью
Java 8 vs. Scala: сравнение возможностей
Так все-таки, Java или Scala? Интернет полнится спорами о том, неужто Scala действительно лучше, чем Java, или «кто вам дал право так утверждать»? Урс Петер и Сандер ван ден Берг озаботились тем, чтобы провести подробное сравнение, из которого следует, что новый Java 8 — это все равно, что улучшенный Scala. Парадокс?
Перевод этой известной в англоязычной части Сети статьи под катом — приводится много практических примеров и листингов.
Введение
Выход JDK 8 (новый комплект для разработки на Java) запланирован на 2013 год, и в Oracle уже вполне четко представляют себе, что в него войдет. Саймон Риттер, выступавший на конференции QCon в Лондоне в этом году, обрисовал новые возможности, которые будут представлены в пакете. В частности, нас ожидают: модульная организация (проект Jigsaw), конвергенция JRockit/Hotspot, аннотирование типов и проект Lambda (примечание от автора блога — в восьмой Яве не будет Jigsaw, его официально пока отложили, так как не успеют к кодефризу, он перенесён на Java 9).
С точки зрения языка наиболее важным изменением является, пожалуй, проект Lambda. Он обеспечивает поддержку лямбда-выражений, виртуальных методов расширения, а также оптимизирует поддержку многоядерных платформ — в виде параллельных коллекций
Большинство этих возможностей уже доступны во многих других языках, работающих с виртуальной машиной Java — в частности, в Scala. Кроме того, многие подходы, взятые на вооружение в Java 8, удивительно похожи на подходы Scala. И значит, упражняясь со Scala, уже можно составить впечатление о том, каким будет язык Java 8.
В этой статье мы изучим новые функции Java 8, ориентируясь как на предполагаемый новый синтаксис Java, так и Scala. Мы рассмотрим лямбда-выражения, функции высшего порядка, параллельные коллекции и виртуальные методы расширения, также называемые «типажами» (traits). Кроме того, мы расскажем о новых парадигмах, которые будут интегрированы в Java 8 — в частности, о функциональном программировании.
Лямбда-выражения/Функции?
Ну наконец-то в Java 8 появятся лямбда-выражения! Правда, в рамках проекта «Lambda» эти выражения доступны уже с 2009 года (тогда они еще назывались «Java-замыканиями»). Прежде, чем перейти к обсуждению примеров кода, стоит объяснить, почему лямбда-выражения — такое полезное дополнение к инструментарию Java.
Зачем нужны лямбда-выражения
Как правило, лямбда-выражения используются при разработке графических пользовательских интерфейсов (GUI). Вообще, программирование GUI строится вокруг соединения поведений с событиями. Например, если пользователь нажимает кнопку (событие), то программа должна выполнить определенное поведение. Поведение может заключаться, например, в сохранении какой-то информации в базе данных.
В Swing, скажем, это делается при помощи ActionListener :
Итак, код стал немного чище. Рассмотрев его внимательнее, мы видим, что по-прежнему создаем экземпляр класса только для того, чтобы вызвать единственный метод. Вот для решения именно таких проблем как раз и применяются лямбда-выражения. Ещё пару примеров можно глянуть вот здесь.
Лямбда-выражения в качестве функций
Лямбда-выражение — это функциональный литерал. Он определяет функцию с входными параметрами и тело функции. Синтаксис лямбда-выражений в Java 8 пока еще обсуждается, но, вероятно, будет выглядеть примерно так:
А вот и конкретный пример:
Это лямбда-выражение вычисляет разницу в длине двух строк. Этот синтаксис можно расширить, в частности, не определяя типы аргументов (такую ситуацию мы рассмотрим ниже). Кроме того, можно создавать многострочные определения, используя < and >, чтобы группировать выражения.
Лямбда-выражения в качестве замыканий
У лямбда-выражений есть ряд интересных свойств. Одно из них состоит в том, что они являются замыканиями. Замыкание обеспечивает для функции доступ к переменным, находящимся вне ее непосредственной лексической области видимости (лексического контекста).
Выведение типа — и для лямбда-выражений
Выведение типа (type inference) — возможность, появившаяся в Java 7, — также применима и к лямбда-выражениям. В сущности, выведение типа заключается в том, что программист может обойтись без определения типа везде, где компилятор сам может вывести тип — то есть определить его дедуктивным методом.
Если применить выведение типа с лямбда-выражением, предназначенным для сортировки, то получится такой код:
Основная польза от выведения типов — в сокращении шаблонного (boilerplate) кода. Если компилятор способен вывести тип за нас — зачем нам самим это делать?
Да здравствуют лямбда-выражения, прощайте, анонимные внутренние классы
Рассмотрим, как лямбда-выражения и выведение типов позволяют упростить пример с обратным вызовом, который мы затронули в начале статьи:
Пока мы не слишком увлеклись примерами использования лямбда-выражений, давайте посмотрим, как аналогичные выражения реализованы в Scala.
Лямбда-выражения в языке Scala
В Scala функциональный литерал записывается следующим образом:
Например, предыдущее лямбда-выражение на Java, вычисляющее разницу длины двух строк, в Scala будет записываться так:
В Scala функциональные литералы также являются замыканиями. Они могут получать доступ к переменным, определенным вне их лексической области видимости.
Функции высшего порядка как многоразовые элементы конструкций
Важнейшее достоинство функциональных литералов заключается в том, что их можно передавать точно так же, как любые другие литералы, вроде строки (String) или произвольного объекта (Object). Такая ситуация открывает широчайшие возможности и позволяет работать с исключительно компактными, многоразовыми программными конструкциями.
Наша первая функция высшего порядка
Когда мы передаем функциональный литерал методу, мы, в сущности, имеем дело с такой ситуацией: один метод принимает другой. Такие методы называются «функциями высшего порядка» (higher-order functions). Метод addActionListener из предыдущего примера кода Swing — именно такой. Мы также можем определять собственные функции высшего порядка, которые нам очень пригодятся.
Рассмотрим простой пример:
Теперь можно передать любой функциональный литерал (или метод) методу измерения:
По сути, мы только что выполнили разделение обязанностей — отделили измерение длины вызова к методу от самих вычислений. Мы создали две многоразовые слабо связанные программные конструкции (измерительную часть и часть обратного вызова) — эту ситуацию можно сравнить с работой функции-перехватчика (interceptor).
Переиспользование при помощи функций высшего порядка
Рассмотрим другой пример, в котором два многоразовых конструкта связаны несколько теснее.
Теперь можно определить различные обратные вызовы, которые могут быть переданы методу doWithContact :
Кроме того, передача обратного вызова может произойти внутристрочно:
В чем польза функций высшего порядка
Видимо, аналогичный код на Java 8 будет выглядеть как-то так:
Как видите, при помощи функций мы реализовали четкое разделение обязанностей: создание объекта домена происходит независимо от его обработки. Таким образом, к программе легко можно подключать новые способы обработки контактных доменных объектов, и при этом их не потребуется сочленять с логикой создания доменного объекта.
Итак, используя функции высшего порядка, мы избавляем код от лишних повторений — таким образом, программист извлекает максимальную пользу из многократного использования кода практически на микроуровне.
Коллекции и функции высшего порядка
Функции высшего порядка обеспечивают эффективный способ работы с коллекциями. Поскольку практически любая программа имеет дело с коллекциями, их обработка может иметь огромное значение.
Фильтрация коллекций: до и после
Давайте рассмотрим типичный пример использования коллекций. Допустим, мы применяем определенное вычисление к каждому элементу коллекции. Например, у нас есть список фотографий (объектов Photo ), и мы хотим выделить все фотографии определенного размера:
Получится примерно такой код. Данный пример написан с использованием Guava.
Шаблон немного сократился, но код по-прежнему остается довольно беспорядочным и пространным. Чтобы в полной мере ощутить потенциал и красоту лямбда-выражений, можно перевести этот код на Java 8 или Scala.
Обе эти реализации красивы и очень лаконичны. Обратите внимание — в обоих вариантах применяется выведение типов: параметр p типа photo явно не определяется. Как мы уже говорили, при работе со Scala вы быстро убедитесь, что выведение типов — стандартная черта этого языка.
Цепочки функций в Scala
Итак, мы сократили код уже минимум на шесть строк и даже улучшили его читаемость. Но самое интересное начинается после сцепления нескольких функций высшего порядка. Чтобы это проиллюстрировать, давайте создадим класс photo и добавим ему дополнительные свойства на языке Scala:
Имея список фотографий, достаточно просто определять различные вопросы, при этом мы будем сцеплять друг с другом по нескольку функций высшего порядка. Предположим, нам требуется извлечь имена всех файлов-изображений, размер которых превышает 10 Мб.
Первый вопрос: как преобразовать список названий фотографий в список имен файлов? Для этого мы воспользуемся одной из наиболее мощных функций высшего порядка, которая называется map :
Рассмотрим более сложный пример:
Задача: «Вернуть имена всех фотографий, чей средний рейтинг выше 6, отсортировав их по общей сумме присвоенных рейтингов».
Цепочки функций в Java 8
Опять же стоит отметить, что в синтаксическом плане разница со Scala практически отсутствует.
Потенциал функций высшего порядка, используемых с коллекциями, очень велик. Они не только очень лаконичны и удобочитаемы, но и позволяют значительно сокращать шаблонный код со всеми вытекающими из этого выгодами — меньше тестов, меньше ошибок. Но и это еще далеко не все.
Параллельные коллекции
До сих пор мы еще не касались одного из самых важных преимуществ, связанных с использованием функций высшего порядка. Такие функции не только улучшают читаемость кода и делают его более кратким, но и добавляют очень важный уровень абстракции. Обратите внимание: во всех предыдущих примерах не было ни одного цикла. Кроме того, для фильтрации коллекций их не приходилось перебирать, ассоциировать (соотносить) или сортировать элементы. Итерация скрыта от пользователя коллекции, говоря иначе, — абстрагирована.
Теоретически все мы можем писать собственный параллельный код. На практике — это не лучший вариант. Во-первых, написание отказоустойчивого параллельного кода с разделяемыми состояниями и получением промежуточных результатов, которые затем потребуется интегрировать, — крайне сложная задача.
Во-вторых, нам не хотелось бы в итоге получить ряд совсем несхожих реализаций. Даже притом, что в Java 7 есть Fork/Join, проблему декомпозиции и пересборки данных приходится решать на стороне клиента, а это не тот уровень абстракции, который нам нужен. И, в-третьих, зачем изобретать велосипед, если решение описанных проблем уже найдено в рамках функционального программирования?
Параллельные коллекции в Scala
Рассмотрим простой пример на Scala, где применяется параллельная обработка:
Далее зададимся вопросом, какой выгоды в плане производительности можно добиться на четырехъядерном компьютере. Чтобы найти ответ, давайте повторно используем измерительный метод, встречавшийся нам выше:
В данном случае довольно странным покажется тот факт, что параллельное исполнение всего в 2,5 раза быстрее последовательного, хотя мы и задействовали все четыре ядра. Причина в том, что при обеспечении параллелизма возникают дополнительные издержки: часть вычислительной мощности тратится на порождение новых потоков и интеграцию промежуточных результатов. Следовательно, не стоит использовать параллельные коллекции по умолчанию, их лучше применять только в ходе интенсивных вычислений.
Параллельные коллекции в Java 8
Интерфейс, который предположительно будет использоваться в Java 8 для работы с параллельными коллекциями, практически такой же, как и в Scala:
А теперь — все сразу
Подведем итог: как может выглядеть работа с функциями высшего порядка/лямбда-выражениями в комбинации с параллельными коллекциями? Для этого мы рассмотрим довольно объемный пример кода на языке Scala. Здесь скомбинированы многие идеи, которые мы обсуждали выше.
Объяснение кода
Метод scrapeWallpapers обрабатывает поток управления, в котором URL изображений выбираются из html-документа, после чего загружается каждое из изображений.
При помощи fetchWallpaperImgURLsOfPage все URL обоев считываются из html, отображаемого на экране.
Объект Http — это класс из HTTP-библиотеки dispatch, которая предоставляет предметно-ориентированный язык (DSL) для работы с библиотекой Apache httpclient. Метод as_tagsouped преобразует html в xml, а xml уже является в Scala встроенным типом данных.
Далее мы получаем из html в виде xml соответствующие href тех изображений, которые хотим загрузить:
Этот метод также показывает, что Scala в полной мере обеспечивает взаимодействие с имеющимися библиотеками Java.
Итак, функциональные черты Scala и связанные с ними очевидные выгоды — в частности, применение функций высшего порядка к коллекциям и «бесплатный» параллелизм — позволяют параллельно выполнять синтаксический анализ, ввод-вывод и преобразование данных. Для этого достаточно всего лишь нескольких строк кода.
Виртуальные методы расширения/типажи
Виртуальные методы расширения в Java напоминают типажи (traits) из Scala. Что же такое «типажи»? Типаж в Scala сразу предоставляет интерфейс и может также включать реализацию — такая структура предлагает массу возможностей.
Однако встает вопрос: если типажи обеспечивают какую-то форму множественного наследования, не подвержены ли они пресловутой «проблеме ромба»?
Ответ: нет, не подвержены. Scala определяет четкий набор правил старшинства (precedence rules), определяющих, какой код когда выполняется в иерархии множественного наследования. Эти правила не зависят от количества примесей. Работая с такими правилами, мы приобретаем все плюсы множественного наследования, но никаких связанных с ним проблем.
Если у нас есть типаж
В следующем примере показан код, понятный всем, кто работал в Java:
Типажи предлагают отличную альтернативу такому паттерну. Если поместить функционал журналирования в типаж, то впоследствии мы сможем смешать этот типаж с любым классом, в какой только захотим. Таким образом, класс получает доступ к сквозной функциональности журналирования — и при этом ничем не ограничиваются возможности наследования от другого класса.
Журналирование в качестве типажа — решение проблемы журналирования
В Scala мы можем реализовать типаж Loggable следующим образом:
Чтобы продемонстрировать, что описанный метод работает, применим метод save() к классу Photo :
Добавление к классам дополнительных поведений
Кроме compare, в типаже Ordered предлагается еще ряд разных методов. Эти методы позволяют сравнивать объекты разнообразными способами, и все они используют реализацию метода compare.
Достоинства типажей
В этом заключается мощный механизм для создания модульного и «сухого» (DRY) кода. В ходе работы с ним мы обходимся лишь встроенными возможностями языка, не прибегая к дополнительным технологиям — например, любимому мной аспектно-ориентированному программированию.
Зачем использовать виртуальные методы расширения?
В спецификации Java 8 содержится черновое описание виртуальных методов расширения. Виртуальные методы расширения добавляют стандартные реализации для новых и/или имеющихся методов имеющихся интерфейсов. А зачем?
Именно поэтому команда разработчиков JDK решила прибегнуть к виртуальным методам расширения. С ними можно, например, добавить метод forEach к интерфейсу java.util.Collection вместе со стандартной реализацией. Следовательно, все использующие его классы будут автоматически наследовать и этот метод, и его реализацию. В таком случае API будет эволюционировать как бы сам по себе, а ведь именно для этого и придуманы виртуальные методы расширения. Но если реализующему классу недостаточно стандартной реализации, то ее просто можно переопределить.
Сравнение виртуальных методов расширения и типажей
Итак, основной причиной для использования виртуальных методов расширения является эволюция API. К тому же работа с ними порождает приятный положительный эффект: обеспечивается своеобразное множественное наследование, проявляющееся только на уровне поведений. А в Scala типажи допускают множественное наследование не только поведений, но и состояния, и даже позволяют ссылаться на реализующий класс (в примере с типажом Loggable мы применили для этого поле self ).
С практической точки зрения типажи предлагают более широкий спектр возможностей, чем виртуальные методы расширения, но используют их по разным причинам. В Scala типажи были задуманы как модульные строительные блоки, которые обеспечивают беспроблемное множественное наследование. В свою очередь, виртуальные методы расширения должны в первую очередь обеспечивать эволюцию API, и уже во вторую — множественное наследование поведений.
Типажи Loggable и Ordered в Java 8
Чтобы оценить, чего можно достичь при помощи виртуальных методов расширения, давайте попробуем реализовать типажи Ordered и Loggable в Java 8.
Типаж Loggable реализуется при помощи виртуальных методов расширения не полностью, но почти полностью:
Итак, и типажи, и виртуальные методы расширения обеспечивают множественное наследование поведений. Типажи, кроме того, обеспечивают и множественное наследование состояний, а также предоставляют способ получения указателя на реализующий класс.
Заключение
В Java 8 будет реализован ряд новых языковых возможностей, которые способны полностью изменить принципы написания приложений на этом языке. Наиболее явными признаками изменения парадигмы можно считать такие элементы функционального программирования, как лямбда-выражения. Это изменение парадигмы открывает новые возможности для написания более четкого, компактного и удобочитаемого кода. Кроме того, лямбда-выражения играют ключевую роль при обеспечении параллельной обработки.
Все описанные здесь возможности уже доступны в языке Scala, как мы это только что описали. Разработчики, желающие с ними познакомиться, могут опробовать ранние сборки Java 8 на большинстве платформ. Можно также присмотреться к Scala, чтобы заранее подготовиться к переменам.
В качестве послесловия. Отблески этой холиварной битвы через призму типичных комментариев взятых с форума:
Это просто разные весовые категории. Scala — это sandbox, Java — industry standart. Перед тем как внедрить что-либо в industry standart, идеи о концепции обкатывают в sandbox’е. А после выхода Java8, ваша Scala фактически станет deprecated. Мне немного жаль ярых поклонников Scala — надо просто понимать, что у всего есть своё предназначение. Как говорят в народе: «Всяк сверчок знай свой шесток».
Спасибо, посмеялся. Scala — это не просто «улучшенная Java», Scala — это отдельный полноценный язык со своей философией, своим очень живым и активным коммьюнити, гайдлайном и т.д. Java никогда не станет настолько же строго типизированной, как Scala, иначе это сломает обратную совместимость, в этом узкое место её «индустриальности» (вы же это за плюс выдаёте).
Java никогда не начнёт использовать необязательный синтаксис, иначе это поломает сами основы этого слишком устоявшегося языка. И, повторюсь: Java никогда не станет community-driven языком, таким как Scala, Ruby, Python или Lisp, иначе это уже будет просто не Oracle Java, а что-то другое. Так что тут просто нечему становиться deprecated. Гораздо более вероятен другой сценарий, при котором Java станет всего лишь одним из многих равноправных языков для JVM, к этому всё и идёт, если вы вспомните всякие Kotlin и так далее.