IntelliJ productivity tips — Секреты самых быстрых разработчиков планеты23.07.2021 15:46

Знать свою машину нужно хотя бы для того, чтобы не стрессовать, если на улице пойдет дождь, а вы не умеете включать дворники. С IntelliJ работает тот же принцип: чтобы быстро и удобно работать, оставаясь в потоке, нужно овладеть кое-какой магией. К счастью, JetBrains позаботились о горячих клавишах — осталось только научиться правильно их применять.

Виктор Рента в своем докладе на JPoint 2021 рассказал о полезных функциях и горячих клавишах IntelliJ, которые могут заметно ускорить ваш кодинг. Следите за руками! Расшифровка доклада и запись — под катом.

Интро

Коротко представлюсь. Я Java-чемпион, а еще — фанат простого дизайна, рефакторинга и юнит-тестирования. Я организовал коммьюнити в Бухаресте, и сейчас это одно из крупнейших коммьюнити в Румынии. Мы фокусируемся как раз на перечисленных мною темах: чистый кодинг, простота дизайна, рефакторинг, юнит-тестирование. Приглашаю всех присоединиться к нашим ежемесячным мероприятиям: они абсолютно бесплатны для членов коммьюнити и проходят на английском.

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

Обычно мои темы крутятся вокруг Java, Spring, Hibernate и функционального программирования, а также Java-производительности. Но чаще всего меня просят провести тренинг по темам, которые даже не связаны напрямую с Java: паттерны предметно-ориентированного проектирования (DDD), рефакторинг чистого кода, юнит-тестирование, реактивное программирование. Особенность этих тренингов в том, что они очень интенсивные. На них невозможно заскучать, полезной информации очень много. Так что если вы хотите связаться со мной, заходите на мой сайт или найдите меня в Twitter. Я сейчас не очень много там пишу, но скоро обязательно вернусь.

Знай свою машину

Для начала я хочу, чтобы вы все вспомнили день, когда впервые сели за руль без вашего инструктора по вождению. Скорее всего, вы взяли с собой парочку запасных футболок и штанов, просто на всякий случай. Вы по сто раз проверяете, что ваш ремень застегнут, зеркала настроены, поворотник включен. Вы включаете первую передачу, внимательно смотрите, чтобы тахометр не переваливал за 3000 оборотов, отпускаете педаль — и понимаете, что вы на ручнике.

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

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

Два года назад я выступал на JPoint и своё выступление начал с фразы: «Я использую Eclipse, извините». Зал посмеялся, но в конце доклада ко мне подошел один из слушателей и сказал, мол, спасибо, но пожалуйста, переключись на IntelliJ. Я уже давно об этом думал, но этот комментарий окончательно подтолкнул меня это сделать. После 13 лет работы на Eclipse я наконец-то перешёл на IntelliJ.

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

Только первые буквы

Начнём шаг за шагом. У меня есть небольшой проект, который я сделал специально для доклада. Скажем, он касается аренды фильмов. Первое, что мне нужно сделать — это ввести клиента. У меня есть класс person, и мне нужно оттуда получить имя клиента. Кто-то будет печатать getFirstName целиком, но на самом деле достаточно ввести первые буквы слов, из которых состоит нужный вам токен. Если вы введёте gfn, IntelliJ сама поймет, что вам нужно, и выдаст имя клиента. Готово!

Это сильно помогает в энтерпрайзных продуктах, где у нас часто есть очень длинные имена. Скажем, класс OrderProcessorAndValidatorService можно сократить до OPAV, и IntelliJ это распознает — очень удобно для больших проектов.

Определяем переменную

Дальше нам, как правило, нужно определить переменную. Как это сделать? Я всегда использую для этого сочетание клавиш Alt + Enter + Enter или Option + Enter для Mac. Этим сочетанием клавиш мы убьём сразу двух зайцев: определим переменную правильного типа и поставим излюбленную точку с запятой в конце строчки.

Также можно быстро и удобно извлечь переменную с помощью шортката Ctrl + Alt + V. В Mac для этого используется Option + Command + V. Alt + Enter + Enter создаёт переменную автоматически, поэтому я давно не делаю этого самостоятельно.

Чистим ошибки и нестыковки

С этим пунктом у меня совершенно особенные отношения. IntelliJ выделяет цветом все ошибки, предупреждения, опечатки и прочее. Чтобы исправить их, нажмите Alt + Enter (Option + Enter для Mac).

Я даже придумал стишок: «When it«s red, yellow, blue, or gray, Alt + Enter will save your day» (Если видишь красное, желтое, синее или серое, то Alt + Enter тебя спасет).

Overdot completion

А теперь я хочу, допустим, вызвать метод. У меня есть переменная от person, и я хочу получить фамилию клиента. Я ввожу всего четыре буквы, p.gln, и IntelliJ заменяет их на person.getLastName ().

Это называется «overdot completion», что означает, что IntelliJ сама додумывает, что идёт после точки. Нажимаем Alt + Enter + Enter, чтобы сделать из LastName переменную, и готово.

Overdot completion также работает для статических членов классов. Например, если вы вводите ldt.now, IntelliJ поймёт, что вы имеете в виду LocalDateTime.

Другой вариант — вы можете получить доступ ко всем этим методам, просто напечатав now и нажав Ctrl + пробел дважды. Если вы просто нажмёте Ctrl + пробел, то IntelliJ не поймёт, что именно вам нужно из одного только now. Два нажатия выдадут вам целый список возможных статических выражений.

Это особенно полезно в тестах. Давайте попробуем. Чтобы сгенерировать тест, я нажимаю Alt + Insert (Command + N для Mac) и в появившемся окне ввожу «test». Я использую live template, который автоматически создает тест — о шаблонах поговорим попозже.

В тесте вы, скорее всего, захотите ввести assertEquals. Если вы нажмёте Ctrl + пробел дважды, и остановитесь на этом, строчка будет выглядеть не очень красиво: assert.assertEquals.

Так мы это оставить не можем. Как исправить ситуацию? Недавно мне написали из JetBrains и подсказали: если я хочу статически импортировать функцию, в диалоговом окне нужно нажать Alt + Enter (Option + Enter в Mac). Кто бы знал, правда?

Вернемся к основному файлу. Я ввожу now, нажимаю Ctrl + пробел дважды, в диалоговом окне выбираю LocalDateTime.now, нажимаю Alt + Enter и выбираю статический импорт. Готово! Нужна переменная — ещё раз Alt + Enter.

Если вы точно знаете, что функция существует и является статической, то можно использовать Ctrl + пробел дважды. Лучше пользоваться этим для ваших собственных служебных функций. Но если вы импортируете функцию из JDK или JUnit, тогда рекомендую статический импорт через Alt + Enter из предложенных вариантов в диалоговом окне.

Антон Архипов: Я добавлю. Когда ты используешь автодополнение после точки для одной переменной, это выглядит эффектно. Но иногда у тебя есть две переменных, начинающихся одинаково. Например, у тебя два person: person1 и person2. Ты все ещё можешь использовать overdot completion, написав первые несколько букв — IntelliJ предложит тебе весь список опций. Здорово, правда?

Виктор Рента: Да, это очень удобно! Если вы работаете над большой сложной фичей, вы явно будете часто вызывать одни и те же методы в разных местах. К этому моменту вы будете уже хорошо знать свою систему и имена методов, поэтому смело используйте overdot completion как можно больше.

Type-safe smart completion

Что это такое? Давайте посмотрим. Например, я знаю, что где-то в коде есть метод methodTakingAMovie. Как мне его найти? Выберите токен и нажмите Ctrl + Shift + F или Ctrl + Command + F для Mac.

Представим, что у нас есть статичный метод, который использует фильм в качестве параметра, и выше, собственно, есть сам фильм.

Movie = new Movie( "a”, Movie.CATEROGY_CHILDRENS); 
public static void methodTakingAMovie(Movie) {
}

Теперь нам нужно вызвать этот метод. Проверьте, что контекст и метод оба статические. Если это так, то вы можете написать первые буквы: mtam. Затем, если вы нажмёте Ctrl + пробел, IntelliJ выдаст вам множество вариантов.

IntelliJ понимает, что вы находитесь в месте, где по контексту вам требуется тип movie. Чтобы представить подходящий параметр в функцию, нажмите Ctrl + Shift + пробел или Ctrl + Command + пробел для Mac. Появятся только те подсказки IntelliJ, которые подходят вам по типу. Если выше у нас представлены два и больше фильмов, то они все появятся в диалоговом окне.

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

Больше, чем один курсор

Для следующего примера давайте перейдем в файл «movies», где у нас хранятся фильмы. Выглядит это так:

Мы уже не в 90-х, поэтому давайте конвертируем константы в enum. Как это сделать? Казалось бы, придется много печатать. Я покажу вам самый быстрый способ превратить константы в enum, используя минимум клавиш.

Выделите строки с категориями и скопируйте их
Поднимите строчки выше в enum
Выделите общую часть для всех строк — public static final int
Нажмите Alt + J или Ctrl + G для Mac

Видите? У нас появилось 3 курсора одновременно. Я могу теперь печатать в три раза быстрее! Одним введением аккуратно поправьте код во всех строчках, чтобы он соответствовал enum-виду. Готово!

Неважно, сколько у вас строчек кода. Alt + J работает в insert-скриптах SQL, JavaScript, в любом языке. В Java это точно ускорит вашу производительность.

Исправить всё

Давайте представим, что мы хотим мигрировать часть кода. Вот то, что у нас есть:

У меня есть красные зоны. Помните стишок про Alt + Enter? Самое время для него: пройдитесь по всем частям, которые вызывают у IntelliJ вопросы. Например, нажав на this.priceCode = priceCode, вы получите целый список возможных решений.

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

Тагир: Кстати, еще можно сделать это для всех спорных моментов сразу. Нажмите Alt + Enter, а потом — стрелку вправо, чтобы выбрать «fix all».

Виктор Рента: Потрясающе! Очень полезно, если у вас есть большой класс из легаси-кода.

Кстати, если у вас есть опечатки, как у меня в слове «CHILDRENS», их тоже можно исправить через Alt + Enter. Я могу этого не видеть, но IntelliJ видит. После того, как вы исправите это в одном месте, система поменяет слово везде.

Связанные проблемы

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

Например, здесь Movie.CATEGORY_CHILDRENS должно быть заменено на Movie.CATEGORY.CHILDRENS. Я снова использую Alt + J, чтобы поправить это одновременно.

Если мы вернемся в наш enum, то увидим, что там появились и другие связанные проблемы. В этом случае оказалось, что в enum нам необязательно повторять Movie каждый раз, поэтому мы и это удалим, используя Alt + J.

И всё, проблемы решены.

Увеличить масштаб

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

Alt + Enter убережёт от ошибки

Посмотрим на пример ниже. В целом, мы можем поднять return price ближе к вычислению в case, и Alt + Enter как раз предлагает нам это сделать.

Это очень мощная функция, потому что иногда вы можете быть неосторожны — там может быть строка, и если она есть, Alt + Enter не предложит вам приблизить return price к вычислению. Так что если у вас появится ощущение, что подвинуть return price можно, не делайте это сами — проверьте через Alt + Enter.

Здесь я добавил строчку Oups a bug, и IntelliJ не даёт мне совершить ошибку.

Еще немного про type-safe completion

Давайте рассмотрим еще один пример. Допустим, внутри enum нам надо вызвать функцию, и тут обычно становится интересно. Если вы нажмёте Ctrl + пробел, вы увидите много-много опций, но все они будут перемешаны по типам.

Кстати, если вы не уверены, какой именно параметр вам нужно поставить, нажмите Ctrl + P (Command + P для Mac) — это сочетание клавиш показывает, какой параметр вы должны поставить на позицию. Очень полезно для enum-перечислений и сложных выражений.

Если мы используем Ctrl + Shift + пробел (Ctrl + Command + пробел для Mac), наши варианты ограничатся теми, которые подходят нам по контексту. В нашем случае нам нужно использовать category — только они и остаются в списке.

Chain completion

Есть одна штука, про которую я знаю, но сам использую не очень часто. Она называется chain completion и выполняется через Ctrl + Shift + дважды пробел (Ctrl + Command + дважды пробел в Mac). Давайте попробуем на практике.

Допустим, у нас есть некоторый rental, внутри которого есть фильм и количество дней аренды. Дальше мы вызываем уже знакомый нам метод methodTakingAMovie. Мне нужно передать фильм, который есть в rental. Ctrl + пробел выдаст мне все доступные опции:

Ctrl + Shift + пробел ограничит варианты до подходящих по контексту.

Ctrl + Shift + дважды пробел найдет выражение, которое может выдать вам фильм в принципе.

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

Boilerplate completion

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

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

Почему это классно? Если вы хотите, чтобы всё было тщательно продумано, особенно в вашей модели сущности, возможно, вам не захочется сгенерировать все геттеры и сеттеры. Возможно, вам захочется защитить некоторые свойства. Таким образом, вставка и генерация всех геттеров и сеттеров может быть не самой разумной идеей в реальных сложных кодовых базах. Поэтому вместо этого я бы рекомендовал людям создавать геттеры и сеттеры по требованию, как это сделал я сейчас. Конечно, в том случае, если вы недостаточно хипстер для использования @getter и @setter.

Но суть именно в том, что вы можете генерировать геттеры и сеттеры по требованию, просто напечатав их названия. То же самое работает и для toString, и для практически всех других опций. Почти всё можно сгенерировать без вставки, просто напечатав названия: геттеры, сеттеры, toString, hashCode, equals.

Изменяем метод

Представим, что мы хотим заменить methodTakingAMovie на methodDifferentAlsoTakingAMovie.

Если мы нажмем на methodTakingAMovie, IntelliJ предложит нам второй вариант, но при нажатии Enter происходит что-то очень страшное и некрасивое:

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

Блестяще, просто, элегантно. Сработает с любой другой частью: например, при смене getFirstName на getLastName. Жмите на Tab — и будет вам «Аве Мария», спокойствие мысли и всё такое.

Заворачиваем выражение в метод

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

Чтобы так сделать, вы можете напечатать mr.s (что означает movie.Repo.save) и нажать Enter. Таким образом вы вызовете метод сохранения. Однако Николай Чашников подсказал мне попробовать Ctrl + Shift + Enter (Ctrl + Command + Enter) — так итоговая строчка получится аккуратнее.

Давайте рассмотрим ещё один пример. Допустим, у нас есть следующее выражение, в котором я намеренно не поставил пробел, хотя я и фанат чистого кода. Если мы поставим курсор перед закрывающей скобкой и нажмем на Ctrl + Shift + Enter, наша строчка примет идеальный и законченный вид:

Пробелы проставлены, скобки открыты, все готово! Если вы хотите создать новый метод, это тоже сработает: после того, как вы напишете базовое выражение и нажмёте Ctrl + Shift + Enter, IntelliJ поймет, что вы имеете в виду.

Работа с операторами

Последнее в списке магии кодерской скорости — это Ctrl + Alt + T (Ctrl + Command + T для Mac), что позволяет завернуть в оператор уже готовый кусок кода. Например, когда вы пишете кусок логики if, иногда вы делаете это с нуля. А иногда требуется преобразовать уже написанную часть. Классический подход — это добавить if перед кодом, открыть скобки и закрыть после сегмента. Но меня это раздражает.

Альтернатива такая: выделить код, который вы хотите обернуть в if, нажать Ctrl +Alt + T и выбрать нужную вам «обертку». Напечатайте ваше условие — и готово, скобки уже расставлены.

Вариантов много: я часто использую if и try/catch, а иногда и try/catch/finally.

Антон Архипов: Если вам нужно обернуть только один стейтмент, его можно даже не выделять — достаточно поставить на него курсор.

Тагир Валеев: А еще в списке опций есть цифры, их можно использовать в качестве шортката. Например, если вам нужен try/catch, то нажмите 6.

Виктор Рента: Да, очень полезная возможность. Еще Антон Архипов упоминал, что, вызывая это же меню, часто использует region fold, чтобы свернуть часть кода с комментариями и описаниями.

Постфиксы

Двигаемся дальше. Предположим, что у нас есть задача: перебрать эти числа, возвести в квадрат все нечётные и вывести их.

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

Но есть способ лучше. Как вы обычно делаете итерацию? Вы начинаете с коллекции. Вернёмся к нашему примеру с прокатом фильмов: у нас есть коллекция Rental. Если мы хотим итерировать эту коллекцию, нам нужно вернуться в начало строки и поставить там for, вспомнить тип, и так далее.

А можно сделать проще — добавить .for в конце строки, и она развернётся целиком.

Я всегда так делаю: IntelliJ сама ставит тип, пробелы, имена. Цифры в начале мы переберём так же: с помощью .for и Enter.

Это называется «postfix expansion». Пожалуй, одна из самых продвинутых функций редактирования кода в IntelliJ, на мой взгляд. Крайне полезно в повседневной практике.

Закончим наше задание с числами. Пишем условие для нечётного числа, в конце ставим .if, нажимаем Enter — и получаем полностью готовое выражение. То же самое, если мне надо перемножить и вывести результат в консоль. Я ставлю .sout в конец строки и нажимаю Enter.

Эта функция работает и с более сложными выражениями.

Можно ли создать постфикс самостоятельно? Да, конечно. Я напомню вам вкус продакшен-кода. Представим, что я создал логгер и хочу сделать так, чтобы .log работал как постфикс. Идем в настройки, находим там вкладку «postfix». Там есть стандартные постфиксы, а мы создадим новый. Выберите Java, введите ключ, который будет запускать постфикс — в нашем случае это log. Затем выберите, к чему он применяется — у нас это non-void. Теперь пишем выражение: log.debug($EXPR$). $EXPR$ здесь — это выражение, которое будет написано у вас перед точкой, и если у вас несколько выражений, то можно поставить галочку напротив «apply to topmost expression», чтобы затрагивалось самое верхнее значение.

Классно, правда? Сработает с любым значением.

Live Template

Итак, еще одна интересная вещь — live template, шаблоны для работы. Давайте на минутку вернёмся к нашему логгеру:

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

Наша аббревиатура будет «logs». Наше выражение записано в поле снизу. Теперь вместо «IntelliJPlay» должно быть что-то характерное для нашего текущего класса. Я точно не знаю, какой у нас текущий класс, поэтому поставлю переменную $CURRENT_CLASS$ и буду её править.

В настройках переменной я ставлю, что текущий класс будет определяться через className, ставлю галочку на «skip if defined». После этого мы видим, что внизу экрана появляется предупреждение — no applicable content. Нажимаем на него и выбираем нужное — в нашем случае это «Declaration».

Шаблон почти готов. Чтобы у нас не возникло проблем дальше, заранее поставим в выражении префиксы «org.slf4j» перед «Logger» и «Logger.Factory», а также поставим галочку напротив «Shorten FQ names» (FQ — fully qualified).

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

Антон Архипов: Я тебя поправлю, Виктор. Ты подошёл к вопросу как истинный пользователь Eclipse: открыл несколько визардов, прошел через поп-апы, проставил на галочки. Вместо этого, если код уже написан, ты можешь нажать Shift дважды и выбрать «Save as live template».

Тагир Валеев: Но в таком случае переменная не создаётся автоматически.

Виктор Рента: Да, поэтому в открытом окне всё ещё придется вставить $CURRENT_CLASS$ и поправить переменную в меню.

Второе — последние открытые файлы, Ctrl + E (Command + E для Mac). Если вы знакомы с этой концепцией, вы можете программировать, как мой друг: в дзен-режиме без видимых вкладок. Нажав Ctrl+ E еще раз и поставив галочку в меню, можно посмотреть последние изменённые файлы.

Третье — часто в энтерпрайз-программах вам приходится вносить много изменений в десяток файлов, прежде чем закоммитить реквест. С помощью Ctrl + Shift + E (Command + Shift + E для Mac) вы сможете посмотреть сниппет, где будут все места, в которых вы вносили изменения за последнее время. Это очень удобное сочетание клавиш, чтобы проконтролировать вашу работу.

И наконец, очень полезная штука для удалёнки. Допустим, вы захотели перенести кусочек логики в другое место и использовали функцию «Вырезать». И тут в комнату врываются ваши дети, начинается хаос. Когда вы минут через 15 возвращаетесь к работе, вы уже вообще не помните, что хотели что-то перенести, и копируете уже что-то другое. В этом случае не пугайтесь — используйте Ctrl + Shift + V (Command + Shift + V для Mac), чтобы посмотреть всё, что вы вообще когда-либо копировали в IntelliJ. История буфера обмена — очень удобная функция.

Конвертация в Java 8

И последнее на сегодня — это Java 8 и конвертация в Java 8. Вернёмся к нашему примеру с цифрами. Допустим, я не хочу выводить результат, а хочу собрать цифры в список. Пойду длинным путем, потерпите:

List results = new ArrayList <>();
for (Integer number : numbers) {
    if (number % 2 == 1) {
        results.add( number * number);
}
}

Здесь у нас файл в Java 7, но вы можете захотеть перевести его стиль в Java 8. Чтобы это сделать, у IntelliJ есть автоматическая функция: нажмите на results с помощью Alt + Enter и замените его на collect. Серьёзно, я не представляю, как ребята из JetBrains додумались до такой логики, но это гениально.

IntelliJ берёт эти синтаксические части из приведённого ниже выражения results и перестраивает в новый вид.

Это работает и в обратную сторону. Очень полезно, если у вашего лида, например, 15 лет опыта в C и он не любит все эти новые стрим-штуки — вы всегда можете вернуться обратно к for-версии.

Есть еще три полезные вещи, которые я покажу на примере. Давайте попробуем написать наше предыдущее выражение с нуля.

Начнем с numbers, и потом скорее всего вы начнете печатать .stream. Но на деле вы можете пропустить его и сразу начать печатать .filter — IntelliJ додумает, что вам требуется.

Дальше дописываем map. Если представить, что выше у нас есть статический метод, который возвращает нам число в квадрате, то при нажатии Ctrl + Shift + пробел мы сможем подставить нужное нам выражение в map.

И, как видите, IntelliJ сама предлагает двойное двоеточие, потому что это подходит под тип, который мне нужен.

Заключающий элемент — collect to list. Некоторые печатают это целиком, но можно просто обойтись сокращениями tol (to list) или ctl (collect to list). Можно использовать cts (collect to set) или, если у вас стрим стрингов, то cj (collect joining).

Приводим все спорные моменты в порядок с помощью Alt + Enter, и всё готово! Если вы используете две стрим-операции, предлагаю разносить их на разные строки. Если у вас один фильтр и сразу же метод collect, то можно оставить всё в одной строке.

Еще немного про навигацию. Предположим, у вас есть большой блок кода — в Java это не редкость, и вам нужно выделить часть внутри оператора if. Но нужный вам код начинается со скобки у if и заканчивается 20 строками ниже. Некоторые люди используют разноцветные режимы, чтобы наслаждаться всеми красками жизни, но мне такое решение не очень нравится. Я предпочитаю программистский способ: Ctrl + W (Option + стрелка вверх для Mac). Это сочетание клавиш выделяет синтаксический блок, окружающий мой курсор. Чем больше я нажимаю эти клавиши, тем сильнее расширяется выделение.

А Ctrl + Shift + W (Option + стрелка вниз для Mac) уменьшает зону выделения. Чтобы вынести тело if, нажмите Ctrl + Alt + M (Option + Command + M для Mac).

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

На этом, пожалуй, у меня всё. Мы закончили, спасибо!

Виктор Рента — смелый, ловкий и умелый — поделился своими приёмами эффективной работы в IntelliJ IDEA. Хотите рассказать о своих или научиться чему-то ещё? Мы анонсировали 8 конференций осеннего сезона, из которых вы можете выбрать ту, которая подойдёт лично вам, или же посетить сразу все. А если хотите выступить, то подать заявку можно уже сейчас на сайте конференции.