Книжная полка Сохранить
Размер шрифта:
А
А
А
|  Шрифт:
Arial
Times
|  Интервал:
Стандартный
Средний
Большой
|  Цвет сайта:
Ц
Ц
Ц
Ц
Ц

Лямбда-выражения в Java 8. Функциональное программирование - в массы

Покупка
Артикул: 487708.02.99
Если вы имеете опыт работы с Java SE, то из этой книги узнаете об изменениях в версии Java 8, обусловленных появлением в языке лямбда-выражений. Вашему вниманию будут представлены примеры кода, упражнения и увлекательные объяснения того, как можно использовать эти анонимные функции, чтобы сделать код проще и чище, и как библиотеки помогают в решении прикладных задач. Лямбда-выражения — относительно простое изменение в языке Java; в первой части книги показано, как правильно ими пользоваться. В последующих главах демонстрируется, как лямбда-выражения позволяют повысить производительность программы за счет распараллеливания, писать более простой конкурентный код и точнее моделировать предметную область, в том числе создавать более качественные предметно-ориентированные языки. Издание предназначено для программистов разной квалификации, как правило уже работающих с Java, но не имеющих опыта функционального программирования.
Уорбэртон, P. Лямбда-выражения в Java 8. Функциональное программирование - в массы / P. Уорбэртон ; пер. с анг. А.А. Слинкина. - Москва : ДМК Пресс, 2014. - 192 с. - ISBN 978-5-94074-919-6. - Текст : электронный. - URL: https://znanium.com/catalog/product/1027843 (дата обращения: 29.03.2024). – Режим доступа: по подписке.
Фрагмент текстового слоя документа размещен для индексирующих роботов. Для полноценной работы с документом, пожалуйста, перейдите в ридер.
Лямбда-выражения в Java 8

Ричард Уорбэртон

Java 8 Lambdas

Functional Programming for the Masses

Richard Warburton

Лямбда-выражения 
в Java 8

Функциональное программирование – 
в массы

Москва, 2014

Ричард Уорбэртон

УДК 004.432.42Java 8
ББК 32.973.26-018.1
 
У62

 
 
Уорбэртон Р.

У62 Лямбда-выражения в Java 8. Функциональное программиро
вание – в массы / пер. с анг. А. А. Слинкина. – М.: ДМК Пресс, 
2014. – 192 с.: ил. 

ISBN 978-5-94074-919-6

Если вы имеете опыт работы с Java SE, то из этой книги узнаете 

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

Лямбда-выражения — относительно простое изменение в языке Java; 

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

Издание предназначено для программистов разной квалификации, 

как правило уже работающих с Java, но не имеющих опыта функционального программирования.

 
УДК  004.432.42Java 8

 
ББК 32.973.26-018.1

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

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

ISBN 978-1-449-37077-0 (анг.) 
Copyright © 2014 Richard 

 
Warburton

ISBN 978-5-94074-919-6 (рус.) 
©  Оформление, перевод, 

 
 
ДМК Пресс, 2014

Содержание

Об авторе ............................................................................................................9

Предисловие..................................................................................................10

Глава 1. Введение ......................................................................................16
Зачем понадобилось снова изменять Java? ................................................16
Что такое функциональное программирование? ....................................18
Пример предметной области ...........................................................................18

Глава 2. Лямбда-выражения ............................................................20
Наше первое лямбда-выражение ...................................................................20
Как опознать лямбда-выражение ..................................................................21
Использование значений .................................................................................23
Функциональные интерфейсы .......................................................................24
Выведение типов .................................................................................................26
Основные моменты ............................................................................................29
Упражнения ..........................................................................................................29

Глава 3. Потоки ............................................................................................31
От внешнего итерирования к внутреннему ...............................................31
Что происходит на самом деле .......................................................................34
Наиболее распространенные потоковые операции ................................36
collect(toList()) .............................................................................................36
map ....................................................................................................................37
filter ...................................................................................................................38
flatMap .............................................................................................................39
max и min ........................................................................................................40
Проявляется общий принцип .................................................................41
reduce ...............................................................................................................43
Объединение операций .............................................................................44
Рефакторинг унаследованного кода .............................................................46
Несколько потоковых вызовов ......................................................................49
Функции высшего порядка .............................................................................50
Полезное применение лямбда-выражений ................................................51
Основные моменты ............................................................................................52

 Содержание

Упражнения ..........................................................................................................53
Упражнения повышенной сложности .........................................................54

Глава 4. Библиотеки ................................................................................55
Использование лямбда-выражений в программе ....................................55
Примитивы ............................................................................................................57
Разрешение перегрузки ....................................................................................59
Аннотация @FunctionalInterface ...................................................................61
Двоичная совместимость интерфейсов .......................................................62
Методы по умолчанию ......................................................................................63
Методы по умолчанию и наследование ...............................................64
Множественное наследование ........................................................................67
Три правила ...................................................................................................68
Компромиссы .......................................................................................................69
Статические методы в интерфейсах .............................................................70
Тип Optional ..........................................................................................................70
Основные моменты ............................................................................................72
Упражнения ..........................................................................................................72
Задача для исследования..................................................................................74

Глава 5. Еще о коллекциях и коллекторах ............................75
Ссылки на методы...............................................................................................75
Упорядочение элементов ..................................................................................76
Знакомство с интерфейсом Collector ...........................................................78
Порождение других коллекций ..............................................................79
Порождение других значений .................................................................80
Разбиение данных .......................................................................................81
Группировка данных ...................................................................................82
Строки .............................................................................................................83
Композиция коллекторов .........................................................................84
Рефакторинг и пользовательские коллекторы .................................86
Редукция как коллектор ...........................................................................94
Усовершенствование интерфейса коллекций ...........................................95
Основные моменты ............................................................................................96
Упражнения ..........................................................................................................97

Глава 6. Параллелизм по данным ................................................98
Параллелизм и конкурентность .....................................................................98
Почему параллелизм важен? ....................................................................... 100
Параллельные потоковые операции.......................................................... 101

Содержание  7

Моделирование ................................................................................................. 102
Подводные камни............................................................................................. 106
Производительность ....................................................................................... 107
Параллельные операции с массивами ...................................................... 110
Основные моменты ......................................................................................... 112
Упражнения ....................................................................................................... 113

Глава 7. Тестирование, отладка и рефакторинг ........... 114
Когда разумно перерабатывать код с использованием 
лямбда-выражений .......................................................................................... 114
Инкапсуляция внутреннего состояния ............................................ 115
Переопределение единственного метода ......................................... 116
Поведенческий паттерн «пиши все дважды».................................. 117
Автономное тестирование лямбда-выражений ..................................... 120
Использование лямбда-выражений в тестовых двойниках .............. 123
Отложенное вычисление и отладка ........................................................... 125
Протоколирование и печать ......................................................................... 125
Решение: метод peek ........................................................................................ 126
Точки останова в середине потока ............................................................. 127
Основные моменты ......................................................................................... 127

Глава 8. Проектирование и архитектурные 
принципы ....................................................................................................... 128
Паттерны проектирования и лямбда-выражения ................................ 129
Паттерн Команда ...................................................................................... 130
Паттерн Стратегия ................................................................................... 133
Паттерн Наблюдатель ............................................................................. 136
Паттерн Шаблонный метод .................................................................. 139
Предметно-ориентированные языки с поддержкой 
лямбда-выражений .......................................................................................... 143
Предметно-ориентированный язык на Java .................................... 144
Как это делается ........................................................................................ 145
Оценка .......................................................................................................... 148
Принципы SOLID и лямбда-выражения................................................. 148
Принцип единственной обязанности ................................................ 149
Принцип открытости-закрытости ...................................................... 152
Принцип инверсии зависимости......................................................... 155
Что еще почитать ............................................................................................. 159
Основные моменты ......................................................................................... 160

 Содержание

Глава 9. Конкурентное программирование 
и лямбда-выражения ........................................................................... 161
Зачем нужен неблокирующий ввод-вывод? ........................................... 161
Обратные вызовы ............................................................................................. 162
Архитектуры на основе передачи сообщений ........................................ 167
Пирамида судьбы ............................................................................................. 168
Будущие результаты ....................................................................................... 171
Завершаемые будущие результаты ............................................................ 173
Реактивное программирование ................................................................... 177
Когда и где .......................................................................................................... 180
Основные моменты ......................................................................................... 181
Упражнения ....................................................................................................... 181

Глава 10. Что дальше? ........................................................................ 183

Алфавитный указатель ...................................................................... 185

Об авторе

Ричард Уорбэртон – технолог-эмпирик, увлекающийся решением 
сложных технических задач, требующих глубокого понимания предмета. Профессионально занимался проблемами статического анализа, верификацией части компилятора и разработкой усовершенствованной автоматизированной технологии обнаружения ошибок. 
Позже заинтересовался методами анализа данных для высокопроизводительных вычислений. Является руководителем лондонского 
сообщества пользователей Java и членом комитета JCP, организует 
процесс подачи запросов на улучшение для Java 8 в части лямбдавыражений и механизмов работы с датой и временем. Ричард также 
часто выступает на конференциях, в том числе JavaOne, DevoxxUK и 
JAX London. Получил степень доктора философии по информатике 
в Варвикском университете, где занимался теоретическими вопросами построения компиляторов.

Предисловие

В течение многих лет функциональное программирование считалось 
уделом небольшой кучки специалистов, неизменно провозглашавших его превосходство, но не способных убедить массы в мудрости 
своего подхода. И эту книгу я написал прежде всего для того, чтобы 
оспорить идею о том, будто функциональному стилю присущи какоето особое превосходство и убежденность в том, что он доступен лишь 
немногим избранным.
Последние два года я убеждал разработчиков, входящих в лондонское сообщество пользователей Java, попробовать те или иные аспекты Java 8. Как оказалось, многим членам нашего сообщества очень 
нравятся предоставленные им новые идиомы и библиотеки. Возможно, их несколько смущают терминология и элитарность технологии, 
но преимущества, которые несет с собой толика несложного функционального программирования, никого не оставляют равнодушными. 
Все согласны, что гораздо проще читать код манипуляции объектами 
и коллекциями, написанный с использованием нового Streams API, – 
например, для выделения музыкальных альбомов, выпущенных в Великобритании, из списка List всех альбомов.
Из опыта проведения таких мероприятий я вынес важный урок – 
все зависит от примеров. Человек учится, решая простые примеры и 
осознавая стоящие за ними закономерности. Я также понял, что терминология легко может оттолкнуть учащегося, поэтому всегда стараюсь объяснять трудные идеи простыми словами.
Для многих механизмы функционального программирования, 
включенные в Java 8, представляются невероятно ограниченными: 
ни тебе монад1, ни отложенных вычислений на уровне языка, ни дополнительной поддержки неизменяемости. С точки зрения программиста-прагматика, это прекрасно; нам нужна возможность выражать 
абстракции на уровне библиотек, чтобы можно быть писать простой и 
чистый код, решающий конкретную задачу. Даже лучше, если кто-то 
уже написал за нас эти библиотеки, чтобы мы могли сосредоточиться 
на своей повседневной работе.

1 Больше это слово в тексте ни разу не встретится.

Предисловие  11

Зачем мне читать эту книгу?

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

Кому стоит прочитать эту книгу?

Эта книга предназначена разработчикам, пишущим на Java, знакомым с основами Java SE и желающим идти в ногу со значительными 
изменениями, появившимися в Java 8.
Если вам интересно узнать о том, что такое лямбда-выражения и 
как они могут повысить ваш профессионализм, читайте дальше! Не 
предполагается никаких предварительных знаний о лямбда-выра жениях или еще каких-то новшествах в базовых библиотеках; все необходимые сведения будут изложены по ходу дела.
Конечно, мне хотелось бы, чтобы каждый разработчик приобрел 
эту книгу, но, по совести говоря, она нужна не всем. Если вы вообще 
не знаете языка Java, то эта книга не для вас. С другой стороны, 
хотя тема лямбда-выражений в Java рассматривается очень подробно, я ничего не рассказываю о том, как они используются в других 
языках.
Не ожидайте введения в такие аспекты Java SE, как коллекции, 
анонимные внутренние классы или механизм обработки событий 
в Swing. Предполагается, что все это вы уже знаете.

Как читать эту книгу

Эта книга построена на примерах: вслед за знакомством с новой концепцией сразу идет код. Иногда в коде может встретиться что-то такое, с чем вы не совсем знакомы. Не пугайтесь – объяснение последует очень скоро, чаще всего в следующем же абзаце.

 Предисловие

У такого подхода есть еще и то достоинство, что он позволяет по 
ходу дела экспериментировать с новыми идеями. Более того, в конце 
многих глав имеются дополнительные примеры для самостоятельной 
работы. Я настоятельно рекомендую выполнять эти упражнения – 
ката. Навык мастера ставит, и – как известно любому программиступрагматику – очень легко впасть в заблуждение, думая, что понимаешь 
какой-то код, тогда как на самом деле упустил из виду важную деталь.
Поскольку смысл лямбда-выражений заключается в том, чтобы 
абстрагировать сложность, убрав ее в библиотеки, то я остановлюсь 
на нескольких приятных нововведениях в общих библиотеках. В главах 2–6 рассматриваются изменения в самом языке и усовершенствованные библиотеки, входящие в состав JDK 8.
Последние три главы касаются практических применений функционального программирования. В главе 7 я расскажу о нескольких 
приемах, упрощающих тестирование и отладку кода. В главе 8 объясняется, как применить к лямбда-выражениям общепринятые принципы правильного проектирования программного обеспечения. Затем, в главе 9, мы поговорим о параллелизме и о том, как с помощью 
лямбда-выражений писать понятный параллельный код, пригодный 
для сопровождения. Там, где это уместно, я буду знакомить вас со сторонними библиотеками.
Первые четыре главы, наверное, стоит рассматривать как вводный 
материал – вещи, которые должен знать всякий, кто хочет правильно 
использовать Java 8. Последующие главы сложнее, зато они научат вас 
полноценно и уверенно применять лямбда-выражения в собственных 
проектах. По всей книге рассыпаны упражнения, решения к ним имеются на сайте в GitHub. Если вы не будете пренебрегать упражнениями, то очень скоро овладеете лямбда-выражениями в совершенстве.

Графические выделения

В книге применяются следующие графические выделения:

Курсив
Новые термины, URL-адреса, адреса электронной почты, имена и расширения имен файлов.

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

Предисловие  13

Моноширинный полужирный
Команды и иной текст, который пользователь должен вводить 
точно в указанном виде.

Моноширинный курсив
Текст, вместо которого следует подставить значения, заданные 
пользователем или определяемые контекстом.

 Так обозначаются совет или рекомендация.

 Так обозначаются примечания общего характера.

 Так обозначаются предупреждения или предостережения.

О примерах кода

Дополнительные материалы (примеры кода, упражнения и т. д.) 
можно скачать с сайта https://github.com/RichardWarburton/java-8lambdas-exercises.
Эта книга призвана помогать вам в работе. Поэтому вы можете 
использовать приведенный в ней код в собственных программах и 
в документации. Спрашивать у нас разрешения необязательно, если 
только вы не собираетесь воспроизводить значительную часть кода. 
Например, никто не возбраняет включить в свою программу несколько фрагментов кода из книги. Однако для продажи или распространения примеров из книг издательства O’Reilly на компакт-диске разрешение требуется. Цитировать книгу и примеры в ответах на вопросы 
можно без ограничений. Но для включения значительных объемов 
кода в документацию по собственному продукту нужно получить разрешение.
Мы высоко ценим, хотя и не требуем, ссылки на наши издания. 
В ссылке обычно указываются название книги, имя автора, издательство и ISBN, например: «Java 8 Lambdas by Richard Warburton 
(O’Reilly). Copyright 2014 Richard Warburton, 978-1-449-37077-0».
Если вы полагаете, что планируемое использование кода выходит 
за рамки изложенной выше лицензии, пожалуйста, обратитесь к нам 
по адресу permissions@oreilly.com.

Как с нами связаться

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

 Предисловие

O’Reilly Media, Inc.
1005 Gravenstein Highway North
Sebastopol, CA 95472
800-998-9938 (в США и Канаде)
707-829-0515 (международный или местный)
707-829-0104 (факс)

Для этой книги имеется веб-страница, на которой публикуются 
списки замеченных ошибок, примеры и прочая дополнительная информация. Адрес страницы: http://oreil.ly/java_8_lambdas.
Замечания и вопросы технического характера следует отправлять 
по адресу bookquestions@oreilly.com.
Дополнительную информацию о наших книгах, конференциях 
и новостях вы можете найти на нашем сайте по адресу http://www.
oreilly.com.
Читайте нас на Facebook: http://facebook.com/oreilly.
Следите за нашей лентой в Twitter: http://twitter.com/oreillymedia.
Смотрите нас на YouTube: http://www.youtube.com/oreillymedia.

Благодарности

Хотя на обложке книги стоит мое имя, ее выходу в свет немало поспособствовали и многие другие.
Прежде всего, хочу сказать спасибо редактору Меган и всему коллективу издательства O’Reilly, благодаря которым процесс оказался очень 
приятным, а сроки – достаточно гибкими. И если бы Мартин и Бен не 
представили меня Меган, то эта книга никогда и не появилась бы.
Рецензирование сильно помогло улучшить книгу, поэтому я сердечно благодарен всем, кто принимал участие в официальном и неофициальном рецензировании: Мартину Вербургу (Martijn Verburg), 
Джиму Гафу (Jim Gough), Джону Оливеру (John Oliver), Эдварду 
Вонгу (Edward Wong), Брайану Гетцу (Brian Goetz), Даниэлю Брайанту (Daniel Bryant), Фреду Розенбергу (Fred Rosenberger), Джайкиран Пай (Jaikiran Pai) и Мани Саркар (Mani Sarkar). А особенно 
Мартину, который таки убедил меня написать техническую книгу.
Нельзя также не упомянуть группу разработчиков проекта Project 
Lambda в Oracle. Модернизировать уже сложившийся язык – задача 
не из легких, и они отлично справились с этой работой в Java 8, заодно 
предоставив мне материал, о котором можно писать. Благодарности 
заслуживает также лондонское сообщество пользователей Java, кото