Coffee break #150. Pag-aralan natin ang mga halimbawa ng mga expression ng lambda sa Java. 7 Pinaka-underrated na Mga Tampok ng IntelliJ IDEA

Pag-aaral ng mga halimbawa ng mga expression ng lambda sa Java

Source: Medium Sa artikulong ito, titingnan natin ang mga expression ng lambda, ang batayan ng functional programming sa Java.

Syntax ng Lambda Expression

Ang syntax ng mga expression ng lambda ay intuitive, madaling maunawaan, at madaling gamitin. Ang isang lambda expression ay binubuo ng:

1. mga parameter ng input
2. arrow ng operator
3. bloke ng mga pagpapahayag/pahayag

Ang pangkalahatang format ay:

<input-params> -> <function-code>

Mga halimbawa ng lambda expression

Ang mga expression ng Lambda ay pinakamahusay na nauunawaan sa pamamagitan ng mga halimbawa, kaya tingnan natin ang ilan sa mga ito.

1. Hindi tumatanggap ng input at hindi nagbabalik ng output

Ang isang simpleng lambda expression ay hindi kumukuha ng anumang input at hindi nagbabalik ng anumang output-ito ay literal na isang bloke ng code na tumatakbo nang walang anumang konteksto.

() -> System.out.println("Here I am!");

Ang pagtukoy sa () sa simula, sa posisyon ng mga parameter ng pag-input, ay nangangahulugan na walang mga parameter na ipinapasa (tulad ng mga walang laman na panaklong na sumusunod sa isang paraan na walang mga parameter).

2. Tumatanggap ng solong input, hindi nagbabalik ng output

Upang gumawa ng isang lambda expression na kumuha ng isang parameter, inilalagay namin ito sa posisyon ng mga parameter ng input:

name -> System.out.println("Here you are too, " + name +  "!");

TANDAAN : Kung mayroon kaming isang parameter ng input, maaari naming alisin ang mga panaklong. Maaari din naming tukuyin (pangalan), ito ay ganap na katanggap-tanggap.

3. Tumatanggap ng maramihang mga input, hindi nagbabalik ng output

Kapag nagpasa kami ng maraming parameter ng input sa isang lambda expression, kailangan naming:

• ilakip ang mga parameter sa panaklong
• gumamit ng kuwit upang paghiwalayin ang mga ito

(name, food) -> System.out.println("So " + name + " enjoys eating " + food + "... interesting!");

4. Naglalaman ng maraming pahayag sa isang seksyon ng code

Ang pag-iimbak ng mga lambda expression sa isang linyang pahayag ay itinuturing na mabuting kasanayan. Ngunit maaari ka ring gumamit ng maraming linya:

() -> {
  System.out.println("The owl and the pussycat went to sea");
  System.out.println("in a beautiful pea green boat");
}

5. Ang mga uri ng pagbabalik ay hindi kailanman tinukoy

Tulad ng maaaring napansin mo, kapag tinutukoy ang isang expression ng lambda, walang mga uri ng pagbabalik na tinukoy. Narito ang isang halimbawa:

() -> System.out.println("I don't return anything!")

At isa pa:

() -> "I return this String!"

Ang parehong mga halimbawa ng code ay halos pareho, ngunit ang pangalawang lambda ay nagbabalik ng isang string. Mangyaring tandaan ito kapag ginagamit ang mga ito. Siyempre, mauunawaan ng tagatala ang pagkakaiba sa pagitan ng mga ito sa pamamagitan ng kondisyonal na paggamit ng mga deskriptor ng function.

6. Ang uri ng hinuha ay awtomatikong inilalapat kung posible

Upang matukoy ang uri, gagamit ang compiler ng uri ng inference. Upang gawin ito, tinitingnan nito ang konteksto ng pagpapatupad ng lambda expression. Para sa developer, nangangahulugan ito na hindi nila kailangang mag-alala tungkol sa pag-cast sa isang partikular na uri.

7. Function Descriptor Notation

Kapag iniisip natin kung anong mga uri ang maaaring italaga sa isang lambda expression, lubhang kapaki-pakinabang na gumamit ng mga function descriptor. Ang isang function handle ay mahalagang isang method signature na ibinibigay ng isang lambda expression (o method). Ang syntax nito ay halos kapareho ng mga expression ng lambda, maliban na sa halip na isang seksyon ng code, mayroong isang seksyon ng uri ng output. Narito ang isang halimbawa:

<input-parameter-types> -> <output-parameter-type>

Mga halimbawa ng mga deskriptor ng function

Narito ang ilang mga halimbawa ng mga deskriptor ng function: () -> () Isang paraan na hindi kumukuha ng mga parameter ng input at hindi nagbabalik ng isang halaga. (String) -> () Paraan na tumatanggap ng input parameter at hindi nagbabalik ng value. () -> (int, float) Isang paraan na hindi kumukuha ng mga parameter ng input at nagbabalik ng int at float(int[]) -> . (SortedMap<Character, Integer>) Paraan na kumukuha ng int array at nagbabalik ng SortedMap mula sa Character patungo sa Integer . Ang pagkakaroon ng mga function descriptor ay nagpapadali sa pagsusuri ng pagiging tugma ng uri kapag isinasaalang-alang kung anong mga uri ng target ang maaari naming gamitin para sa isang lambda expression.

Konklusyon

Tulad ng nakikita mo, ang mga expression ng lambda ay isang maayos at simpleng paraan upang i-encapsulate ang pag-uugali. Ito ay isa sa mga pundasyon ng functional programming paradigm na ipinakilala sa Java sa paglabas ng JDK 8.

7 Pinaka-underrated na Mga Tampok ng IntelliJ IDEA

Pinagmulan: Better Programming Mahirap paniwalaan, ngunit makalipas ang maraming taon, nakikilala ko pa rin ang mga taong hindi alam ang tungkol sa magagandang feature na ito sa IntelliJ IDEA.

1.Maghanap ng kahit ano

Medyo mahirap tandaan ang bawat kumbinasyon ng key at subaybayan ang lahat ng magagawa ng IntelliJ IDEA. Ito ang dahilan kung bakit madalas akong gumagamit ng paghahanap sa loob ng IntelliJ IDEA. Nakakatulong ito sa akin na mahanap ang mga item sa menu, tool, setting, at maging ang mga file na kailangan ko sa isang lugar.

2. Alamin kung nasaan ka

Bago ko mahanap ang feature na ito, ginamit ko ang "Select Open File" na buton para ipakita ang kasalukuyang na-edit na file sa project tree. Ngayon ginagawa ito ng IntelliJ IDEA para sa akin. Ito ay hindi isang default na opsyon, kaya kakailanganin mong itakda ito para sa bawat bago o umiiral na proyekto.

3. Pag-optimize ng SQL

Alam mo ba na ang default na database plugin sa iyong IDE ay higit pa sa isang simpleng SQL executor? Dahil sa katotohanan na ang persistence layer (I/O) ay palaging ang pinakamabagal na bahagi ng application, palagi kong tinitiyak na ang aking mga query sa SQL ay may magandang plano sa pagpapatupad kapag nagtatrabaho sa mga relational database.

4. Multiline na pag-edit

Maaaring nagamit mo na ang feature na ito sa Sublime Text Editor dati.

5. Bumalik / Pasulong

Madalas talaga akong bumalik sa kung saan ako dati sa pamamagitan ng pagpindot sa back o forward buttons. Bumalik/pasulong: ⌥⌘+kaliwa/kanang arrow (Ctrl+Alt+kaliwa/kanang arrow para sa Win/Linux). Upang buksan ang mga kamakailang file, pindutin ang ⌘E (Ctrl+E para sa Win/Linux).

6. Mga bookmark

Nag-bookmark ako ng mga mahahalagang bahagi ng code para mabilis akong maka-refer sa kanila anumang oras. Upang pumunta sa isang bookmark, pindutin ang ⌃+<number> (Ctrl+<number> para sa Win/Linux). Sasabihin ko kaagad na hindi ako gumagamit ng higit sa tatlong mga bookmark sa isang pagkakataon, dahil pagkatapos ay nagiging mahirap na matandaan kung para saan ang mga ito.

7. Isang editor para sa lahat

Nagbukas ako noon ng iba pang mga text editor tulad ng Visual Studio Code o Sublime para i-save ang mga bahagi ng code, JSON, XML, at pagkatapos ay mag-link sa kanila. Ngunit hindi ito bahagi ng codebase (proyekto), at malinaw na ipinapaalala sa iyo ng IntelliJ IDEA ito kapag sinubukan mong gumawa o mag-edit ng isang bagay na tulad nito. Pagkatapos ay nakita ko ang isa sa aking mga kasamahan na gumagamit ng mga Snippet at napagtanto ko kung gaano ito galing. Bagong Snippet file: ⇧⌘N (Shift+Ctrl+N para sa Win/Linux). Available at naka-sync ang mga snippet sa lahat ng window ng iyong mga proyekto. Madalas kong ginagamit ang mga ito upang suriin at i-format ang ilang JSON o SQL na nakuha ko mula sa ibang lugar.

My secret recipe

Ang icing sa cake ay isang feature na nakakatipid sa akin ng isang toneladang oras ng pag-type araw-araw: Ang Tabnine ay isang JetBrains plugin para sa pag-compile ng AI-powered Intellij IDEA code. Sa ngayon ay libre, ngunit bilisan mo, hindi ko akalain na ito ay magtatagal.