Java 8 Functies met Voorbeelden

Handleidingen

Java 8 werd uitgebracht op 18 maart 2014. Dat is al lang geleden, maar nog steeds draaien veel projecten op Java 8. Dat komt omdat het een grote release was met veel nieuwe functies. Laten we eens kijken naar alle spannende en belangrijke functies van Java 8 met voorbeeldcode.

Snelle Overzicht van Java 8 Functies

Enkele van de belangrijke Java 8-functies zijn;

  1. forEach() methode in Iterable interface
  2. Standaard- en statische methoden in Interfaces
  3. Functionele Interfaces en Lambda Expressies
  4. Java Stream API voor Bulkgegevensbewerkingen op Collecties
  5. Java Time API
  6. Verbeteringen aan Collection API
  7. Verbeteringen aan Concurrency API
  8. Verbeteringen aan Java IO

Laten we kort kijken naar deze Java 8-functies. Ik zal enkele codefragmenten geven voor een beter begrip van de functies op een eenvoudige manier.

1. forEach() methode in Iterable interface

Telkens wanneer we door een collectie moeten traverseren, moeten we een Iterator maken met als enige doel te itereren, en dan hebben we bedrijfslogica in een lus voor elk van de elementen in de collectie. We kunnen een ConcurrentModificationException krijgen als de iterator niet correct wordt gebruikt.

Java 8 heeft de forEach-methode geïntroduceerd in de java.lang.Iterable-interface zodat we ons bij het schrijven van code kunnen concentreren op de bedrijfslogica. De forEach-methode neemt een java.util.function.Consumer-object als argument, dus het helpt om onze bedrijfslogica op een aparte locatie te hebben die we kunnen hergebruiken. Laten we forEach-gebruik bekijken met een eenvoudig voorbeeld.

package com.journaldev.java8.foreach;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.function.Consumer;
import java.lang.Integer;

public class Java8ForEachExample {

	public static void main(String[] args) {
		
		// voorbeeldcollectie maken
		List<Integer> myList = new ArrayList<Integer>();
		for(int i=0; i<10; i++) myList.add(i);
		
		// traverseren met behulp van Iterator
		Iterator<Integer> it = myList.iterator();
		while(it.hasNext()){
			Integer i = it.next();
			System.out.println("Iterator Value::"+i);
		}
		
		// traverseren via forEach-methode van Iterable met anonieme klasse
		myList.forEach(new Consumer<Integer>() {

			public void accept(Integer t) {
				System.out.println("forEach anonymous class Value::"+t);
			}

		});
		
		// traverseren met Consumer-interface-implementatie
		MyConsumer action = new MyConsumer();
		myList.forEach(action);
		
	}

}

// Consumer-implementatie die hergebruikt kan worden
class MyConsumer implements Consumer<Integer>{

	public void accept(Integer t) {
		System.out.println("Consumer impl Value::"+t);
	}
}

Het aantal regels kan toenemen, maar de forEach-methode helpt om de logica voor iteratie en bedrijfslogica op afzonderlijke plaatsen te hebben, wat resulteert in een hogere scheiding van zorgen en schonere code.

2. standaard en statische methoden in Interfaces

Als je de details van de forEach-methode zorgvuldig leest, zul je opmerken dat deze gedefinieerd is in de Iterable-interface, maar we weten dat interfaces geen methode-lichaam kunnen hebben. Vanaf Java 8 zijn interfaces verbeterd om een methode met implementatie te hebben. We kunnen de default en static sleutelwoorden gebruiken om interfaces met methodenimplementatie te maken. De implementatie van de forEach-methode in de Iterable-interface is: 

default void forEach(Consumer<? super T> action) {
    Objects.requireNonNull(action);
    for (T t : this) {
        action.accept(t);
    }
}

We weten dat Java geen meervoudige overerving in klassen biedt omdat dit leidt tot het Diamantprobleem. Dus hoe zal dit nu worden afgehandeld met interfaces aangezien interfaces nu vergelijkbaar zijn met abstracte klassen?

De oplossing is dat de compiler in dit scenario een uitzondering zal genereren en dat we de implementatielogica moeten verstrekken in de klasse die de interfaces implementeert. 

package com.journaldev.java8.defaultmethod;

@FunctionalInterface
public interface Interface1 {

	void method1(String str);
	
	default void log(String str){
		System.out.println("I1 logging::"+str);
	}
	
	static void print(String str){
		System.out.println("Printing "+str);
	}
	
	//poging om de Object-methode te overschrijven geeft een compileerfout als
	//"Een standaardmethode kan geen methode van java.lang.Object overschrijven"
	
// standaard String toString(){
// return "i1";
// }
	
}

package com.journaldev.java8.defaultmethod;

@FunctionalInterface
public interface Interface2 {

	void method2();
	
	default void log(String str){
		System.out.println("I2 logging::"+str);
	}

}

Let op dat beide interfaces een gemeenschappelijke methode log() hebben met implementatielogica.

package com.journaldev.java8.defaultmethod;

public class MyClass implements Interface1, Interface2 {

	@Override
	public void method2() {
	}

	@Override
	public void method1(String str) {
	}

	// MyClass compileert niet zonder zijn eigen log() implementatie
	@Override
	public void log(String str){
		System.out.println("MyClass logging::"+str);
		Interface1.print("abc");
	}
	
}

Zoals u kunt zien heeft Interface1 een statische methode-implementatie die wordt gebruikt in de MyClass.log()-methode-implementatie. Java 8 gebruikt standaard en statische methoden veel in de Collectie-API en standaardmethoden worden toegevoegd zodat onze code achterwaarts compatibel blijft.

Als een klasse in de hiërarchie een methode heeft met dezelfde signatuur, worden standaardmethoden irrelevant. Object is de basisklasse, dus als we equals(), hashCode() standaardmethoden in de interface hebben, worden ze irrelevant. Daarom zijn interfaces niet toegestaan om standaardmethoden van Object te hebben voor betere duidelijkheid.

Voor volledige details van de interface-wijzigingen in Java 8, lees alstublieft Java 8 interface-wijzigingen.

3. Functionele interfaces en Lambda-expressies

Als je de bovenstaande interfacecode opmerkt, zul je de annotatie @FunctionalInterface opmerken. Functionele interfaces zijn een nieuw concept geïntroduceerd in Java 8. Een interface met precies één abstracte methode wordt een Functionele Interface. We hoeven geen @FunctionalInterface-annotatie te gebruiken om een interface als Functionele Interface te markeren.

@FunctionalInterface-annotatie is een faciliteit om te voorkomen dat er per ongeluk abstracte methoden worden toegevoegd aan de functionele interfaces. Je kunt het vergelijken met de @Override-annotatie en het is een goede praktijk om het te gebruiken. java.lang.Runnable met een enkele abstracte methode run() is een geweldig voorbeeld van een functionele interface.

Een van de belangrijkste voordelen van de functionele interface is de mogelijkheid om lambda-expressies te gebruiken om ze te instantiëren. We kunnen een interface instantiëren met een anonieme klasse, maar de code ziet er omvangrijk uit. 

Runnable r = new Runnable(){
			@Override
			public void run() {
				System.out.println("My Runnable");
			}};

Aangezien functionele interfaces slechts één methode hebben, kunnen lambda-expressies gemakkelijk de methode-implementatie bieden. We moeten alleen methode-argumenten en bedrijfslogica opgeven. Bijvoorbeeld, we kunnen bovenstaande implementatie schrijven met behulp van een lambda-expressie als:

Runnable r1 = () -> {
			System.out.println("My Runnable");
		};

Als je slechts één instructie in de methode-implementatie hebt, hebben we ook geen accolades nodig. Bijvoorbeeld kan de anonieme klasse Interface1 hierboven worden geïnstantieerd met lambda als volgt:

Interface1 i1 = (s) -> System.out.println(s);
		
i1.method1("abc");

Lambda-expressies zijn een middel om eenvoudig anonieme klassen van functionele interfaces te maken. Er zijn geen voordelen op runtime van het gebruik van lambda-expressies, dus ik zal het voorzichtig gebruiken omdat het me niet erg vindt om een paar extra regels code te schrijven.

A new package java.util.function has been added with bunch of functional interfaces to provide target types for lambda expressions and method references. Lambda expressions are a huge topic, I will write a separate article on that in the future.

U kunt de volledige tutorial lezen op Java 8 Lambda Expressions Tutorial.

4. Java Stream API voor bulkgegevensbewerkingen op collecties

A new java.util.stream has been added in Java 8 to perform filter/map/reduce like operations with the collection. Stream API will allow sequential as well as parallel execution. This is one of the best features for me because I work a lot with Collections and usually with Big Data, we need to filter out them based on some conditions.

De Collection-interface is uitgebreid met de standaardmethoden stream() en parallelStream() om de Stream te verkrijgen voor sequentiële en parallelle uitvoering. Laten we hun gebruik bekijken aan de hand van een eenvoudig voorbeeld.

package com.journaldev.java8.stream;

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Stream;

public class StreamExample {

	public static void main(String[] args) {
		
		List<Integer> myList = new ArrayList<>();
		for(int i=0; i<100; i++) myList.add(i);
		
		//sequentiële stream
		Stream<Integer> sequentialStream = myList.stream();
		
		//parallelle stream
		Stream<Integer> parallelStream = myList.parallelStream();
		
		//lambda gebruiken met Stream API, filtervoorbeeld
		Stream<Integer> highNums = parallelStream.filter(p -> p > 90);
		//lambda gebruiken in forEach
		highNums.forEach(p -> System.out.println("High Nums parallel="+p));
		
		Stream<Integer> highNumsSeq = sequentialStream.filter(p -> p > 90);
		highNumsSeq.forEach(p -> System.out.println("High Nums sequential="+p));

	}

}

Als u het bovenstaande voorbeeldcode uitvoert, krijgt u een uitvoer zoals deze:

High Nums parallel=91
High Nums parallel=96
High Nums parallel=93
High Nums parallel=98
High Nums parallel=94
High Nums parallel=95
High Nums parallel=97
High Nums parallel=92
High Nums parallel=99
High Nums sequential=91
High Nums sequential=92
High Nums sequential=93
High Nums sequential=94
High Nums sequential=95
High Nums sequential=96
High Nums sequential=97
High Nums sequential=98
High Nums sequential=99

Merk op dat de parallelle verwerkingswaarden niet in volgorde zijn, dus parallelle verwerking zal zeer nuttig zijn bij het werken met enorme collecties.

Het is niet mogelijk om alles over de Stream API te behandelen in deze post, je kunt alles over de Stream API lezen op Java 8 Stream API Voorbeeld Tutorial.

5. Java Time API

Het is altijd moeilijk geweest om te werken met Datum, Tijd, en Tijdzones in Java. Er was geen standaardbenadering of API in Java voor datum en tijd. Een van de mooie toevoegingen in Java 8 is het java.time-pakket dat het proces van werken met tijd in Java zal stroomlijnen.

Alleen al door te kijken naar de Java Time API-pakketten, kan ik voelen dat ze zeer gemakkelijk te gebruiken zullen zijn. Het heeft enkele subpakketten zoals java.time.format die klassen bieden om datums en tijden af te drukken en te parseren, en java.time.zone biedt ondersteuning voor tijdzones en hun regels.

De nieuwe Time API geeft de voorkeur aan enums boven gehele getallen voor maanden en dagen van de week. Een van de nuttige klassen is DateTimeFormatter voor het converteren van DateTime-objecten naar strings. Voor een volledige tutorial, ga naar Java Date Time API Voorbeeld Tutorial.

6. Verbeteringen aan de Collection API

We hebben al de forEach() methode en Stream API voor collecties gezien. Enkele nieuwe methoden toegevoegd in de Collection API zijn:

  • Iterator standaardmethode forEachRemaining(Consumer action) om de gegeven actie uit te voeren voor elk overgebleven element totdat alle elementen zijn verwerkt of de actie een uitzondering veroorzaakt.
  • Collection standaardmethode removeIf(Predicate filter) om alle elementen van deze collectie te verwijderen die voldoen aan de gegeven voorwaarde.
  • Collection spliterator() methode die een Spliterator-instantie retourneert die kan worden gebruikt om elementen sequentieel of parallel te doorlopen.
  • Map replaceAll(), compute(), merge() methoden.
  • Prestatieverbetering voor de HashMap-klasse met sleutelconflicten

7. Concurrency API-verbeteringen

Enkele belangrijke verbeteringen aan de gelijktijdige API zijn:

  • ConcurrentHashMap compute(), forEach(), forEachEntry(), forEachKey(), forEachValue(), merge(), reduce() en search() methoden.
  • CompletableFuture die expliciet kan worden voltooid (door de waarde en status in te stellen).
  • Executors newWorkStealingPool() methode om een work-stealing-threadpool te maken met als doel parallelisme het aantal beschikbare processoren.

8. Java IO-verbeteringen

Enkele IO-verbeteringen die mij bekend zijn, zijn:

  • Files.list(Path dir) die een lui ingevulde Stream retourneert, waarvan de elementen de vermeldingen in de map zijn.
  • Files.lines(Path path) die alle regels uit een bestand leest als een Stream.
  • Files.find() die een Stream retourneert die lui wordt gevuld met Path door te zoeken naar bestanden in een bestandsstructuur die begint bij een opgegeven startbestand.
  • BufferedReader.lines() die een Stream retourneert waarvan de elementen regels zijn die uit deze BufferedReader zijn gelezen.

Diverse Java 8 Core API-verbeteringen

Enkele diverse API-verbeteringen die handig kunnen zijn, zijn:

  1. ThreadLocal statische methode withInitial(Supplier supplier) om eenvoudig instanties te maken.
  2. De Comparator-interface is uitgebreid met veel standaard- en statische methoden voor natuurlijke volgorde, omgekeerde volgorde, enz.
  3. min(), max() en sum() methoden in Integer, Long en Double wrapper-klassen.
  4. De methoden logicalAnd(), logicalOr() en logicalXor() in de Boolean klasse.
  5. ZipFile.stream() methode om een geordende Stream te verkrijgen over de ZIP-bestandsonderdelen. Onderdelen verschijnen in de Stream in de volgorde waarin ze voorkomen in het centrale directory van het ZIP-bestand.
  6. Verschillende hulpprogramma-methoden in de Math klasse.
  7. jjs opdracht is toegevoegd om de Nashorn Engine te starten.
  8. jdeps opdracht is toegevoegd om class-bestanden te analyseren.
  9. De JDBC-ODBC Bridge is verwijderd.
  10. De PermGen-geheugenruimte is verwijderd.

Dat is alles voor Java 8 functies met voorbeeldprogramma’s. Als ik belangrijke functies van Java 8 heb gemist, laat het me dan weten via opmerkingen.

Source:
https://www.digitalocean.com/community/tutorials/java-8-features-with-examples