Pengaturcaraan Fungsian dalam Java

Pengaturcaraan berfungsi Java wujud selepas versi Java 8^th 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

Mulakan Kursus Pembangunan Perisian Percuma Anda

Pembangunan web, bahasa pengaturcaraan, ujian perisian & lain-lain

• Strim Pengaturcaraan Fungsional
• Pengaturcaraan Fungsian Lambda Expressions
• Pengaturcaraan Fungsian Rujukan Kaedah

Bagaimanakah pengaturcaraan Fungsian berfungsi dalam Java?

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.

Contoh Pengaturcaraan Fungsian dalam Java

Diberikan di bawah adalah contoh yang dinyatakan:

Contoh #1: Aliran Pengaturcaraan Fungsional

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:

• Dalam kelas Java, kami menjana setter dan getter.
• Kami menulis kod utama untuk mencetak nama anjing dalam kelas Java.
• Dalam kod itu sendiri, nyatakan tujuan setiap baris dalam ulasan.
• Jika kita menulis kod yang sama dalam pengaturcaraan berstruktur, kita perlu menulis lebih banyak baris untuk setiap kaedah seperti filter(), collector(), findAny(), map(), dll. Jadi, kebanyakan pembangunan pengaturcaraan berfungsi lebih diutamakan daripada pengaturcaraan berstruktur.

Contoh #2: Ungkapan Lambda

• Ungkapan lambda digunakan untuk mewakili antara muka kaedah dengan ungkapan.
• Ia membantu untuk mengulang, menapis dan mengekstrak data daripada koleksi.
• Pelaksanaan antara muka ungkapan Lambda ialah antara muka berfungsi.
• Ia mengurangkan banyak kod.
• Ungkapan lambda dianggap sebagai fungsi, jadi pengkompil java tidak boleh mencipta .class

Sintaks:

(arguments) ->
{
//code for implementation
}
Arguments:  argument-list can be have values or no values
Example: arguments1, arguments2, arguments3,……
->: Joins code implementation and arguments.

a. Ungkapan Lambda dengan satu hujah

Sintaks:

(argument1) ->
{
//code for implementation
}

Contoh – AreaOfSquare.java

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:

• Yang di atas mencipta antara muka Square dan di dalam kelas AreaOfSquare ditulis ungkapan lambda.
• Dalam ungkapan lambda, logik bertulis untuk luas segi empat sama.
• Dalam baris terakhir yang dicetak, luas segi empat sama 100 dengan memanggil kaedah antara muka getArea().

b.  Ungkapan Lambda tanpa hujah

Sintaks:

() ->
{
//code for implementation
}

Contoh – MyNameString.java

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:

• Di atas mencipta nama antara muka dan di dalam kelas MyNameString ditulis ungkapan lambda tanpa hujah.
• Dalam ungkapan lambda, logik bertulis untuk rentetan pemulangan.
• Dalam baris terakhir yang dicetak, rentetannya ialah Hai, Amardeep! Dengan memanggil kaedah antara muka getMyName().

Contoh #3: Rujukan Kaedah

• Rujukan kaedah digunakan untuk merujuk kepada kaedah antara muka berfungsi.
• Ia adalah satu lagi bentuk ungkapan lambda yang lebih mudah.
• Jika anda menggunakan ungkapan lambda setiap kali untuk menunjuk kaedah, kami boleh menggunakan rujukan kaedah sebagai ganti rujukan kaedah.

Sintaks:

Class-Name:: static method name

Contoh – StaticMethodReference.java

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 :

• Ce qui précède a créé une interface Rectangle et, à l'intérieur de la classe StaticMethodReference, a écrit le code de référence de la méthode statique.
• Dans la méthode showRectangleArea(), logique écrite pour l'aire d'un rectangle.
• La ligne suivante a transmis la référence de méthode statique à la référence d'interface RectangleArea.
• Ensuite, imprimez une ligne sur la zone du rectangle en appelant la méthode getArea(10,20).
• Donne une sortie de 200.

Conclusion

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!