Funktionale Programmierung in Java

Java Functional Programming wird ab Java 8^derVersion eingeführt. Funktionale Programmierung bedeutet eine grundlegende Änderung des Ansatzes zur Problemlösung. Die funktionale Programmierung ermöglicht das Programmieren mit Ausdrücken (Deklarieren von Funktionen), das Übergeben von Funktionen als Argumente und die Verwendung von Funktionen als Anweisungen.

Arten der funktionalen Programmierung

WERBUNG Beliebter Kurs in dieser Kategorie PROGRAMMIERSPRACHEN - Spezialisierung | 54 Kursreihe | 4 Probetests

Starten Sie Ihren kostenlosen Softwareentwicklungskurs

Webentwicklung, Programmiersprachen, Softwaretests und andere

• Streams Funktionale Programmierung
• Funktionale Programmierung mit Lambda-Ausdrücken
• Methodenreferenz Funktionale Programmierung

Wie funktioniert funktionale Programmierung in Java?

Bevor wir uns mit dem Konzept der funktionalen Programmierung befassen, wollen wir uns den Unterschied zwischen funktionaler und strukturierter Programmierung ansehen. Bei der strukturierten Programmierung liegt der Schwerpunkt auf der logischen Struktur oder dem logischen Prozess, während sich die funktionale Programmierung hauptsächlich auf Daten konzentriert. Die strukturierte Programmierung folgt einem Top-Down-Ansatz, während die funktionale Programmierung von unten nach oben erfolgt.

Funktionale Programmierung ist in winzige Laufzeiteinheiten, sogenannte Objekte, unterteilt, während strukturierte Programmierung kleine Einheiten oder Funktionen unterteilt. Strukturierte Programmierung ist weniger sicher, wohingegen funktionale Programmierung sehr sicher ist. Strukturierte Programmierung kann keine komplexen Probleme bewältigen, wohingegen funktionale Programmierung jede Ebene eines komplexen Problems behandelt.

Beispiele für funktionale Programmierung in Java

Im Folgenden finden Sie die genannten Beispiele:

Beispiel #1: Funktionale Programmierung von Streams

Syntax:

objectName.stream();

Code:

Animal.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;
}
}

AnimalNames.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
}
}

Ausgabe:

Erklärung:

• In der Java-Klasse generieren wir Setter und Getter.
• Wir schreiben den Hauptcode zum Drucken von Hundenamen in der Java-Klasse.
• Erwähnen Sie im Code selbst den Zweck jeder Zeile im Kommentar.
• Wenn wir den gleichen Code in der strukturierten Programmierung schreiben, müssen wir mehr Zeilen für jede Methode schreiben, z. B. filter(), Collector(), findAny(), map() usw. Daher wird der Entwicklung der meisten funktionalen Programmierung der Vorzug gegeben strukturierte Programmierung.

Beispiel #2: Lambda-Ausdrücke

• Ein Lambda-Ausdruck wird verwendet, um eine Methodenschnittstelle mit einem Ausdruck darzustellen.
• Es hilft, Daten aus Sammlungen zu iterieren, zu filtern und zu extrahieren.
• Die Implementierung der Lambda-Ausdrucksschnittstelle ist eine funktionale Schnittstelle.
• Es reduziert viel Code.
• Ein Lambda-Ausdruck wird als Funktion behandelt, sodass der Java-Compiler keine .class erstellen kann

Syntax:

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

a. Lambda-Ausdruck mit einem einzigen Argument

Syntax:

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

Beispiel – AreaOfSquare.java

Code:

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
}
}

Ausgabe:

Erklärung:

• Das Obige hat eine Schnittstelle Square erstellt und in der AreaOfSquare-Klasse einen Lambda-Ausdruck geschrieben.
• Im Lambda-Ausdruck geschriebene Logik für die Fläche eines Quadrats.
• In der letzten Zeile wird die Fläche des Quadrats von 100 durch Aufrufen der Schnittstellenmethode getArea() gedruckt.

b.  Lambda-Ausdruck ohne Argument

Syntax:

() ->
{
//code for implementation
}

Beispiel – MyNameString.java

Code:

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
}
}

Ausgabe:

Erklärung:

• Das Obige hat einen Schnittstellennamen erstellt und in der MyNameString-Klasse einen Lambda-Ausdruck ohne Argument geschrieben.
• Im Lambda-Ausdruck geschriebene Logik für die Rückgabezeichenfolge.
• In der letzten gedruckten Zeile lautet die Zeichenfolge Hi, Amardeep! Durch Aufruf der Schnittstellenmethode getMyName().

Beispiel #3: Methodenreferenz

• Methodenreferenz wird verwendet, um auf eine Methode einer funktionalen Schnittstelle zu verweisen.
• Es ist eine weitere einfache Form eines Lambda-Ausdrucks.
• Wenn Sie den Lambda-Ausdruck jedes Mal verwenden, um auf eine Methode zu verweisen, können wir anstelle der Methodenreferenz eine Methodenreferenz verwenden.

Syntax:

Class-Name:: static method name

Beispiel – StaticMethodReference.java

Code:

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
}
}

Ausgabe:

Erklärung:

• Das Obige hat ein Interface-Rechteck erstellt und in der StaticMethodReference-Klasse einen statischen Methodenreferenzcode geschrieben.
• Innerhalb der showRectangleArea()-Methode geschriebene Logik für die Fläche eines Rechtecks.
• In der nächsten Zeile wurde die statische Methodenreferenz an die Schnittstellenreferenz „RectangleArea“ übergeben.
• Als nächstes drucken Sie die rechteckige Fläche linienförmig aus, indem Sie die Methode getArea(10,20) aufrufen.
• Ergibt eine Ausgabe von 200.

Fazit

Funktionale Programmierung wird mit Streams, Lambda-Ausdrücken und Methodenreferenzen erreicht. Es reduziert Codezeilen und verbessert die Leistung.

Das obige ist der detaillierte Inhalt vonFunktionale Programmierung in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!