streamalism.org

1. Overzicht

In deze zelfstudie leren we verschillende manieren om meerdere waarden van een Java-methode te retourneren.

Eerst retourneren we arrays en verzamelingen. Vervolgens laten we zien hoe u containerklassen kunt gebruiken voor complexe gegevens en hoe u generieke tupelklassen kunt maken.

Ten slotte zullen we voorbeelden zien van het gebruik van bibliotheken van derden om meerdere waarden te retourneren.

2. Arrays gebruiken

Arrays kunnen worden gebruikt om zowel primitieve als referentiegegevens te retourneren.

Bijvoorbeeld de volgende getCoordinates methode retourneert een array van twee dubbele waarden:

double [] getCoordinatesDoubleArray () {double [] coordinates = new double [2]; coördinaten [0] = 10; coördinaten [1] = 12,5; terugkeer coördinaten; }

Als we een array van verschillende referentietypen willen retourneren, kunnen we een gemeenschappelijk bovenliggend type gebruiken als het type van de array:

Number [] getCoordinatesNumberArray () {Number [] coordinates = new Number [2]; coördinaten [0] = 10; // Geheel getal coördinaten [1] = 12,5; // Dubbele retourcoördinaten; }

Hier hebben we de coördinaten array van type Aantal omdat het de gemeenschappelijke klasse is tussen Geheel getal en Dubbele elementen.

3. Collecties gebruiken

Met generieke Java-verzamelingen, we kunnen meerdere waarden van een algemeen type retourneren.

Het verzamelingsraamwerk heeft een breed spectrum aan klassen en interfaces. In deze sectie beperken we onze discussie echter tot de Lijst en Kaart interfaces.

3.1. Waarden van vergelijkbaar type retourneren in een lijst

Laten we om te beginnen het vorige array-voorbeeld herschrijven met Lijst:

Lijst getCoordinatesList () {Lijst coördinaten = nieuwe ArrayList (); coordinates.add (10); // Geheel getal coordinaten. Add (12.5); // Dubbele retourcoördinaten; }

Leuk vinden Aantal[], de Lijst collectie bevat een reeks elementen van gemengd type die allemaal van hetzelfde algemene type zijn.

3.2. Benoemde waarden in een kaart teruggeven

Als we elk item in onze collectie een naam willen geven, a Kaart kan in plaats daarvan worden gebruikt:

Kaart getCoordinatesMap () {Kaartcoördinaten = nieuwe HashMap (); coordinates.put ("lengtegraad", 10); coordinates.put ("latitude", 12.5); terugkeer coördinaten; }

Gebruikers van het getCoordinatesMap methode kan de “Lengtegraad" of "breedtegraad" sleutels met de Kaart # get methode om de bijbehorende waarde op te halen.

4. Containerklassen gebruiken

In tegenstelling tot arrays en verzamelingen, containerklassen (POJO's) kunnen meerdere velden met verschillende gegevenstypen omsluiten.

Bijvoorbeeld het volgende Coördinaten klasse heeft twee verschillende gegevenstypen, dubbele en Draad:

openbare klasse Coördinaten {privé dubbele lengtegraad; privé dubbele breedtegraad; private String placeName; openbare coördinaten (dubbele lengtegraad, dubbele breedtegraad, String placeName) {this.longitude = lengtegraad; this.latitude = breedtegraad; this.placeName = placeName; } // getters en setters}

Het gebruik van containerklassen zoals Coördinaten stelt ons in staat om complexe datatypes te modelleren met betekenisvolle namen.

De volgende stap is het instantiëren en retourneren van een exemplaar van Coördinaten:

Coördinaten getCoordinates () {dubbele lengtegraad = 10; dubbele breedtegraad = 12,5; String placeName = "home"; retourneer nieuwe coördinaten (lengtegraad, breedtegraad, plaatsnaam); }

Dat moeten we opmerken het wordt aanbevolen dat we dataklassen maken zoals Coördinaten onveranderlijk. Door dit te doen, creëren we eenvoudige, threadveilige, deelbare objecten.

5. Tuples gebruiken

Net als containers slaan tuples velden van verschillende typen op. Ze verschillen echter doordat ze niet toepassingsspecifiek zijn.

Ze zijn gespecialiseerd wanneer we ze gebruiken om te beschrijven welke typen we willen dat ze behandelen, maar ze zijn een container voor algemeen gebruik van een bepaald aantal waarden. Dit betekent dat we geen aangepaste code hoeven te schrijven om ze te hebben, en dat we een bibliotheek kunnen gebruiken of een gemeenschappelijke enkele implementatie kunnen maken.

Een tuple kan uit een willekeurig aantal velden bestaan ​​en wordt vaak aangeroepen Tuplen, waarbij n het aantal velden is. Tuple2 is bijvoorbeeld een tupel met twee velden, Tuple3 is een tupel met drie velden, enzovoort.

Laten we het volgende voorbeeld bekijken om het belang van tuples aan te tonen. Stel dat we de afstand tussen a willen vinden Coördinaten punt en alle andere punten binnen een Lijst. Vervolgens moeten we dat verste coördinatenobject teruggeven, samen met de afstand.

Laten we eerst een generiek tupel met twee velden maken:

openbare klasse Tuple2 {privé K eerst; privé V tweede; openbare Tuple2 (K eerste, V tweede) {this.first = eerste; this.second = tweede; } // getters en setters}

Laten we vervolgens onze logica implementeren en een Tuple2 instantie om de resultaten te verpakken:

Tuple2 getMostDistantPoint (List coordinatesList, Coordinates target) {return coordinatesList.stream () .map (coor -> new Tuple2 (coor, coor.calculateDistance (target))) .max ((d1, d2) -> Double.compare (d1 .getSecond (), d2.getSecond ())) // vergelijk afstanden .get (); }

Gebruik makend van Tuple2 in het vorige voorbeeld heeft ons behoed voor het maken van een aparte containerklasse voor eenmalig gebruik met deze specifieke methode.

Zoals containers, tuples zouden onveranderlijk moeten zijn. Bovendien, vanwege hun algemene aard, we zouden tuples intern moeten gebruiken in plaats van als onderdeel van onze openbare API.

6. Bibliotheken van derden

Sommige bibliotheken van derden hebben een onveranderlijk Paar of Verdrievoudigen type. Apache Commons Lang en javatuples zijn goede voorbeelden. Zodra we die bibliotheken als afhankelijkheden in onze applicatie hebben, kunnen we de Paar of Verdrievoudigen typen die door de bibliotheken worden geleverd in plaats van ze door onszelf te maken.

Laten we een voorbeeld bekijken met Apache Commons Lang om een Paar of een Verdrievoudigen voorwerp.

Voordat we verder gaan, voegen we het commons-lang3 afhankelijkheid in onze pom.xml:

 org.apache.commons commons-lang3 3.9 

6.1. Onveranderlijk paar van Apache Commons Lang

De Onveranderlijk paar type van Apache Commons Lang is precies wat we willen: een onveranderlijk type waarvan het gebruik eenvoudig is.

Het bevat twee velden: links en Rechtsaf. Laten we eens kijken hoe we onze kunnen maken getMostDistantPoint methode retourneert een object van de Onveranderlijk paar type:

ImmutablePair getMostDistantPoint (List coordinatesList, Coordinates target) {return coordinatesList.stream () .map (coordinates -> ImmutablePair.of (coordinates, coordinates.calculateDistance (target))) .max (Comparator.comparingDouble (Pair :: getRight)). krijgen(); }

6.2. Onveranderlijk Triple van Apache Commons Lang

De Onveranderlijk Triple is vrij gelijkaardig aan de Onveranderlijk paar. Het enige verschil is, zoals de naam al zegt, een Onveranderlijk Triple bevat drie velden: links, midden, en Rechtsaf.

Laten we nu een nieuwe methode toevoegen aan onze coördinatenberekening om te laten zien hoe we de Onveranderlijk Triple type.

We gaan door alle punten in a Lijst om de min, gemiddeld, en max. hoogte afstanden tot het opgegeven richtpunt.

Laten we eens kijken hoe we de drie waarden kunnen retourneren met een enkele methode met behulp van de Onveranderlijk Triple klasse:

ImmutableTriple getMinAvgMaxTriple (List coordinatesList, Coordinates target) {List distanceList = coordinatesList.stream () .map (coordinates -> coordinates.calculateDistance (target)) .collect (Collectors.toList ()); Double minDistance = distanceList.stream (). MapToDouble (Double :: doubleValue) .min (). GetAsDouble (); Double avgDistance = distanceList.stream (). MapToDouble (Double :: doubleValue) .average (). OrElse (0.0D); Double maxDistance = distanceList.stream (). MapToDouble (Double :: doubleValue) .max (). GetAsDouble (); return ImmutableTriple.of (minDistance, avgDistance, maxDistance); }

7. Conclusie

In dit artikel hebben we geleerd hoe u arrays, verzamelingen, containers en tuples kunt gebruiken om meerdere waarden van een methode te retourneren. We kunnen arrays en verzamelingen in eenvoudige gevallen gebruiken, omdat ze een enkel gegevenstype bevatten.

Aan de andere kant zijn containers en tuples handig bij het maken van complexe typen, waarbij containers beter leesbaar zijn.

We hebben ook vernomen dat sommige bibliotheken van derden paar- en drievoudige typen hebben geïmplementeerd en we hebben enkele voorbeelden gezien uit de Apache Commons Lang-bibliotheek.

Zoals gewoonlijk is de broncode voor dit artikel beschikbaar op GitHub.