Rumah >Java >javaTutorial >Pengaturcaraan Fungsian dalam Java
Pengaturcaraan berfungsi Java wujud selepas versi Java 8th dan seterusnya. Pengaturcaraan fungsional bermaksud perubahan asas dalam pendekatan penyelesaian masalah. Pengaturcaraan fungsional membenarkan pengaturcaraan dengan ungkapan (mengisytiharkan fungsi), menghantar fungsi sebagai argumen dan menggunakan fungsi sebagai pernyataan.
Jenis Pengaturcaraan Fungsional
IKLAN Kursus Popular dalam kategori ini BAHASA PENGATURCARAAN - Pengkhususan | 54 Siri Kursus | 4 Ujian Olok-olokMulakan Kursus Pembangunan Perisian Percuma Anda
Pembangunan web, bahasa pengaturcaraan, ujian perisian & lain-lain
Sebelum kita masuk ke dalam konsep pengaturcaraan berfungsi, mari lihat perbezaan antara pengaturcaraan Fungsian dan berstruktur. Pengaturcaraan berstruktur menekankan struktur atau proses logik, manakala pengaturcaraan Fungsional tertumpu terutamanya pada data. Pengaturcaraan berstruktur mengikut pendekatan atas ke bawah, manakala Pengaturcaraan Fungsian mengikut dari bawah ke atas.
Pengaturcaraan fungsian dipisahkan kepada entiti masa jalan kecil yang dipanggil objek, manakala pengaturcaraan berstruktur memisahkan unit atau fungsi kecil. Pengaturcaraan berstruktur kurang selamat, manakala pengaturcaraan Fungsian sangat selamat. Pengaturcaraan berstruktur tidak dapat menangani masalah yang kompleks, manakala pengaturcaraan Fungsian mengendalikan sebarang tahap masalah yang kompleks.
Diberikan di bawah adalah contoh yang dinyatakan:
Sintaks:
objectName.stream();
Kod:
Haiwan.java
package com.streams; public class Animal { String name; String color; public String getName() { return name; } public void setName(String name) { this.name = name; } public String getColor() { return color; } public void setColor(String color) { this.color = color; } public Animal(String name, String color) { super(); this.name = name; this.color = color; } }
Nama Haiwan.java
package com.streams;//creating package //importing required packages to the code import java.util.Arrays; import java.util.List; import java.util.stream.Collectors; public class AnimalNames { public static void main(String[] args) { getMyDogNames();//calling the method } private static void getMyDogNames() { Animal a1=new Animal("Puppy","black"); //creating a object for animal class Animal a2=new Animal("Tommy","brown");//creating a object for animal class Animal a3=new Animal("Zimmy","white");//creating a object for animal class List<Animal> persons = Arrays.asList(a1,a2,a3); //passing object references to list String dogName = persons.stream() //covert all elements into stream .filter(name -> "Puppy".equals(name.getName()))//filtering given elements from persons class .map(Animal::getName) //persons elements iterate over map .findAny()//find out the given element passed from filter .orElse("");// System.out.println("Dog Name :" + dogName); //print the dog name List<String> collect = persons.stream() .map(Animal::getName) .collect(Collectors.toList());//collecting all names from list System.out.println("All Dog names"); collect.forEach(System.out::println);//iterating collection with for each loop } }
Output:
Penjelasan:
Sintaks:
(arguments) -> { //code for implementation } Arguments: argument-list can be have values or no values Example: arguments1, arguments2, arguments3,…… ->: Joins code implementation and arguments.
Sintaks:
(argument1) -> { //code for implementation }
Kod:
package com.lambda;//creating a package interface Square{ //creating interface for quare public int getArea(int side); //create a method for get area } public class AreaOfSquare{ //As we are working with Lambda expression so no need to implement interface of square public static void main(String[] args) { Square area=(side)->{ // Lambda expression with only one argument. Return side*side; //returning area }; System.out.println(“Area of Square=>”+area.getArea(10)); //printing area by calling interface getArea method } }
Output:
Penjelasan:
Sintaks:
() -> { //code for implementation }
Kod:
package com.lambda;//creating a package interface Name{ //creating interface for Name public String getMyName(); //create a method for get name } public class MyNameString{ //As we are working with Lambda expression so no need to implement interface of Name public static void main(String[] args) { Name name=()->{ // Lambda expression with out argument. return "Hi, Amardeep!"; //returning name }; System.out.println(name.getMyName()); //printing name by calling interface getMyName method } }
Output:
Penjelasan:
Sintaks:
Class-Name:: static method name
Kod:
package method.reference;//creating package interface RectangleArea{ //creating RectangleArea interface public int getArea(int l,int b); //creating method getArea in interface } public class StaticMethodReference { //creating a classs public static int showRectangleArea(int length, int breadth){ //creating method for getting rectangle area return length*breadth; } public static void main(String[] args) { // Referring static method RectangleArea area = StaticMethodReference::showRectangleArea; //calling class name with method name // Calling interface method int outArea=area.getArea(10,20); System.out.println("Area of rectangle :"+outArea);//printing area } }
Output:
Explication :
La programmation fonctionnelle est réalisée avec des flux, des expressions lambda et des références de méthodes. Cela réduit les lignes de code et améliore les performances.
Atas ialah kandungan terperinci Pengaturcaraan Fungsian dalam Java. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!