Rückgabe mehrerer Werte in einer Java-Methode (Generics, Record, Triple, Tuple unter Verwendung von Standardbibliotheken und externen Bibliotheken)

Überblick

Umgebung

Externe Bibliothek, die Sie verwenden

Methode ohne Verwendung einer externen Bibliothek

Standardbibliothek java.lang.Object []

Gibt eine Reihe von Werten in einem Array von Objekten zurück. Der Empfänger benötigt eine Besetzung.

public class ArraySample {

  static Object[] getArray() {
    Object[] array = new Object[3];
    array[0] = "foo";
    array[1] = true;
    array[2] = 123456;
    return array;
  }

  public static void main(String[] args) {
    Object[] array = getArray();
    String  foo = (String) array[0];
    boolean bar = (boolean) array[1];
    int     baz = (int) array[2];
    System.out.println(foo);
    System.out.println(bar);
    System.out.println(baz);
  }
}

Standardbibliothek java.util.List

Setzen Sie den Wert auf das Element List und geben Sie ihn zurück. Der Empfänger benötigt eine Besetzung.

import java.util.ArrayList;
import java.util.List;

public class ListSample {

  static List<Object> getList() {
    ArrayList<Object> list = new ArrayList<>();
    list.add("foo");
    list.add(true);
    list.add(123456);
    return list;
  }

  public static void main(String[] args) {
    List<Object> list = getList();
    String  foo = (String) list.get(0);
    boolean bar = (boolean) list.get(1);
    int     baz = (int) list.get(2);
    System.out.println(foo);
    System.out.println(bar);
    System.out.println(baz);
  }
}

Standardbibliothek java.util.Map

Gibt eine Reihe von Werten für Kartenelemente zurück. Der Empfänger benötigt eine Besetzung.

import java.util.HashMap;
import java.util.Map;

public class MapSample {

  static Map<String, Object> getMap() {
    HashMap<String, Object> map = new HashMap<>();
    map.put("foo", "foo");
    map.put("bar", true);
    map.put("baz", 123456);
    return map;
  }

  public static void main(String[] args) {
    Map<String, Object> map = getMap();
    String  foo = (String) map.get("foo");
    boolean bar = (boolean) map.get("bar");
    int     baz = (int) map.get("baz");
    System.out.println(foo);
    System.out.println(bar);
    System.out.println(baz);
  }
}

Definieren Sie eine Klasse

Definieren Sie eine Klasse, setzen Sie einen Wert in das Feld und kehren Sie zurück.

public class ClassSample {

  static class MyClass {
    String foo;
    boolean bar;
    int baz;
  }

  static MyClass getMyClass() {
    MyClass cls = new MyClass();
    cls.foo = "foo";
    cls.bar = true;
    cls.baz = 123456;
    return cls;
  }

  public static void main(String[] args) {
    MyClass cls = getMyClass();
    String  foo = cls.foo;
    boolean bar = cls.bar;
    int     baz = cls.baz;
    System.out.println(foo);
    System.out.println(bar);
    System.out.println(baz);
  }
}

Definieren Sie eine generisierte Klasse

Definieren Sie eine generische Klasse und geben Sie den Typ an, wenn Sie sie verwenden. Stellen Sie einen Wert in das Feld ein und geben Sie ihn zurück.

public class GenericsSample {

  static class ValuesGenerics<T1, T2, T3> {
    T1 foo;
    T2 bar;
    T3 baz;
  }

  static ValuesGenerics<String, Boolean, Integer> getGenerics() {
    ValuesGenerics<String, Boolean, Integer> generics = new ValuesGenerics<>();
    generics.foo = "foo";
    generics.bar = true;
    generics.baz = 123456;
    return generics;
  }

  public static void main(String[] args) {
    ValuesGenerics<String, Boolean, Integer> generics = getGenerics();
    String  foo = generics.foo;
    boolean bar = generics.bar;
    int     baz = generics.baz;
    System.out.println(foo);
    System.out.println(bar);
    System.out.println(baz);
  }
}

Definieren Sie einen Datensatz

Definieren und verwenden Sie Datensätze (die offiziell ab Java 16 eingeführt werden sollen).

public class RecordSample {

  record ValuesRecord(String foo, boolean bar, int baz) {
  }

  static ValuesRecord getRecord() {
    return new ValuesRecord("foo", true, 123456);
  }

  public static void main(String[] args) {
    ValuesRecord record = getRecord();
    String  foo = record.foo;
    boolean bar = record.bar;
    int     baz = record.baz;
    System.out.println(foo);
    System.out.println(bar);
    System.out.println(baz);
  }
}

Referenz: JEP 384: Records \ (Second Preview )

So verwenden Sie eine externe Bibliothek

Kotlin Standard Library (kotlin.Triple)

Verwenden Sie die Standardbibliothek von Kotlin aus Java. Kotlins Standardbibliothek umfasst Pair, das zwei Werte verarbeitet, und Triple, das drei Werte verarbeitet.

import kotlin.Triple;

public class KotlinSample {

  static Triple<String, Boolean, Integer> getTriple() {
    return new Triple<>("foo", true, 123456);
  }

  public static void main(String[] args) {
    Triple<String, Boolean, Integer> triple = getTriple();
    String  foo = triple.getFirst();
    boolean bar = triple.getSecond();
    int     baz = triple.getThird();
    System.out.println(foo);
    System.out.println(bar);
    System.out.println(baz);
  }
}

Referenz: Triple \ -Kotlin-Programmiersprache

Scala Standard Library (scala.Tuple3)

Verwenden Sie die Standardbibliothek von Scala aus Java. Die Standardbibliotheken von Scala reichen von Tuple1 für einen Wert bis Tuple22 für 22 Werte.

import scala.Tuple3;

public class ScalaSample {

  static Tuple3<String, Boolean, Integer> getTuple3() {
    return new Tuple3<>("foo", true, 123456);
  }

  public static void main(String[] args) {
    Tuple3<String, Boolean, Integer> tuple = getTuple3();
    String  foo = tuple._1();
    boolean bar = tuple._2();
    int     baz = tuple._3();
    System.out.println(foo);
    System.out.println(bar);
    System.out.println(baz);
  }
}

Referenz: Scala Standard Library 2 \ .13 \ .3 \ -scala \ .Tuple3

Apache Commons Lang (org.apache.commons.lang3.tuple.Triple)

Apache Commons Lang verfügt über ein Paar, das zwei Werte verarbeitet, und ein Triple, das drei Werte verarbeitet.

import org.apache.commons.lang3.tuple.Triple;

public class ApacheCommonsLangSample {

  static Triple<String, Boolean, Integer> getTriple() {
    return Triple.of("foo", true, 123456);
  }

  public static void main(String[] args) {
    Triple<String, Boolean, Integer> triple = getTriple();
    String  foo = triple.getLeft();
    boolean bar = triple.getMiddle();
    int     baz = triple.getRight();
    System.out.println(foo);
    System.out.println(bar);
    System.out.println(baz);
  }
}

Referenz: [Triple \ (Apache Commons Lang 3 \ .11 API )](https://commons.apache.org/proper/commons-lang/javadocs/api-release/org/apache/commons/lang3/tuple/ Triple.html)

Functional Java (fj.P3)

Das funktionale Java reicht von P1 für einen Wert bis P8 für acht Werte.

import fj.P;
import fj.P3;

public class FunctionalJavaSample {

  static P3<String, Boolean, Integer> getP3() {
    return P.p("foo", true, 123456);
  }

  public static void main(String[] args) {
    P3<String, Boolean, Integer> p = getP3();
    String  foo = p._1();
    boolean bar = p._2();
    int     baz = p._3();
    System.out.println(foo);
    System.out.println(bar);
    System.out.println(baz);
  }
}

Referenz: P3 \ (Core 4 \ .8 \ .1 API )

javatuples (org.javatuples.Triplet)

javatuples reicht von Einheiten, die einen Wert verarbeiten, bis zu Jahrzehnten, die zehn Werte verarbeiten.

import org.javatuples.Triplet;

public class JavatuplesSample {

  static Triplet<String, Boolean, Integer> getTriplet() {
    return Triplet.with("foo", true, 123456);
  }

  public static void main(String[] args) {
    Triplet<String, Boolean, Integer> triplet = getTriplet();
    String  foo = triplet.getValue0();
    boolean bar = triplet.getValue1();
    int     baz = triplet.getValue2();
    System.out.println(foo);
    System.out.println(bar);
    System.out.println(baz);
  }
}

Referenz: Triplet \ (javatuples 1 \ .2 API )

jOOλ (org.jooq.lambda.tuple.Tuple3)

jOOλ reicht von Tuple0, das 0 Werte verarbeitet, bis Tuple16, das 16 Werte verarbeitet.

import org.jooq.lambda.tuple.Tuple;
import org.jooq.lambda.tuple.Tuple3;

public class JoolSample {

  static Tuple3<String, Boolean, Integer> getTuple3() {
    return Tuple.tuple("foo", true, 123456);
  }

  public static void main(String[] args) {
    Tuple3<String, Boolean, Integer> tuple = getTuple3();
    String  foo = tuple.v1();
    boolean bar = tuple.v2();
    int     baz = tuple.v3();
    System.out.println(foo);
    System.out.println(bar);
    System.out.println(baz);
  }
}

Referenz: [Tuple3 \ (jOOL 0 \ .9 \ .14 API )](https://www.jooq.org/products/jOO%ce%bb/javadoc/0.9.14/org/jooq/lambda/tuple /Tuple3.html)

Reactor (reactor.util.function.Tuple3)

Der Reaktor reicht von Tuple2, das zwei Werte verarbeitet, bis zu Tuple8, das acht Werte verarbeitet.

import reactor.util.function.Tuple3;
import reactor.util.function.Tuples;

public class ReactorSample {

  static Tuple3<String, Boolean, Integer> getTuple3() {
    return Tuples.of("foo", true, 123456);
  }

  public static void main(String[] args) {
    Tuple3<String, Boolean, Integer> tuple = getTuple3();
    String  foo = tuple.getT1();
    boolean bar = tuple.getT2();
    int     baz = tuple.getT3();
    System.out.println(foo);
    System.out.println(bar);
    System.out.println(baz);
  }
}

Referenz: [Tuple3 \ (Reaktor \ -core 3 \ .3 \ .10 \ .RELEASE )](https://projectreactor.io/docs/core/3.3.10.RELEASE/api/reactor/util/function/ Tuple3.html)

Vavr (io.vavr.Tuple3)

Vavr reicht von Tuple0, das 0 Werte verarbeitet, bis Tuple8, das 8 Werte verarbeitet.

import io.vavr.Tuple;
import io.vavr.Tuple3;

public class VavrSample {

  static Tuple3<String, Boolean, Integer> getTuple3() {
    return Tuple.of("foo", true, 123456);
  }

  public static void main(String[] args) {
    Tuple3<String, Boolean, Integer> tuple = getTuple3();
    String  foo = tuple._1();
    boolean bar = tuple._2();
    int     baz = tuple._3();
    System.out.println(foo);
    System.out.println(bar);
    System.out.println(baz);
  }
}

Referenz: Tuple3 \ (Vavr 0 \ .10 \ .3 API )

Beispielcode-Ausführungsdatei

build.gradle

plugins {
  id 'java'
  id 'application'
}

repositories {
  mavenCentral()
}

dependencies {
  //Erforderliche Bibliotheken
  implementation 'org.jetbrains.kotlin:kotlin-stdlib:1.4.10'
  implementation 'org.scala-lang:scala-library:2.13.3'
  implementation 'org.apache.commons:commons-lang3:3.11'
  implementation 'org.functionaljava:functionaljava:4.8.1'
  implementation 'org.javatuples:javatuples:1.2'
  implementation 'org.jooq:jool:0.9.14'
  implementation 'io.projectreactor:reactor-core:3.3.10.RELEASE'
  implementation 'io.vavr:vavr:0.10.3'
}

sourceCompatibility = JavaVersion.VERSION_15
mainClassName = "App"

tasks.withType(JavaCompile) {
  //Verwenden Sie die Java 15-Vorschaufunktion
  options.compilerArgs += ['--enable-preview']
}

application {
  //Verwenden Sie die Java 15-Vorschaufunktion
  applicationDefaultJvmArgs = ['--enable-preview']
}

Beispielcode-Stapelausführungsklasse

public class App {

  public static void main(String[] args) {
    ArraySample.main(args);
    ListSample.main(args);
    MapSample.main(args);
    ClassSample.main(args);
    GenericsSample.main(args);
    RecordSample.main(args);
    KotlinSample.main(args);
    ScalaSample.main(args);
    ApacheCommonsLangSample.main(args);
    FunctionalJavaSample.main(args);
    JavatuplesSample.main(args);
    JoolSample.main(args);
    ReactorSample.main(args);
    VavrSample.main(args);
  }
}

Referenzmaterial

Recommended Posts

Rückgabe mehrerer Werte in einer Java-Methode (Generics, Record, Triple, Tuple unter Verwendung von Standardbibliotheken und externen Bibliotheken)
So konvertieren Sie A in a und a in A mit logischem Produkt und Summe in Java
Versuchen Sie, mit Scala mithilfe der Standardbibliothek von Java Text zu einem Bild hinzuzufügen
[Java] Verschlüsselung mit AES-Verschlüsselung mit Standardbibliothek
So testen Sie die Java-Vorschaufunktion (z. B. Java 15 Record) mit IntelliJ
So beheben Sie den unbekannten Fehler, der bei der Verwendung von slf4j in Java aufgetreten ist
Wie man JAVA in 7 Tagen lernt
So fügen Sie eine externe Bibliothek ein
[Java] Versuchen Sie, mithilfe von Generika zu implementieren
Verwendung von Klassenmethoden [Java]
Wie verwende ich Klassen in Java?
So benennen Sie Variablen in Java
So verketten Sie Zeichenfolgen mit Java
So implementieren Sie eine Diashow mit Slick in Rails (einzeln und mehrfach nacheinander)
So testen Sie eine private Methode, die ein Array- oder Argument variabler Länge in JUnit verwendet