Comment renvoyer plusieurs valeurs dans une méthode Java (Generics, Record, Triple, Tuple, en utilisant des bibliothèques standard et des bibliothèques externes)

Aperçu

environnement

Bibliothèque externe que vous utilisez

Méthode sans utiliser de bibliothèque externe

Bibliothèque standard java.lang.Object []

Renvoie un ensemble de valeurs dans un tableau d'objets. Le destinataire a besoin d'un casting.

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

Bibliothèque standard java.util.List

Définissez la valeur sur l'élément de List et renvoyez-le. Le destinataire a besoin d'un casting.

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

Bibliothèque standard java.util.Map

Renvoie un ensemble de valeurs pour les éléments Map. Le destinataire a besoin d'un casting.

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

Définir une classe

Définissez une classe, définissez une valeur dans le champ et renvoyez.

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

Définir une classe générique

Définissez une classe générique et spécifiez le type lors de son utilisation. Définissez une valeur dans le champ et renvoyez-la.

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

Définir un enregistrement

Définir et utiliser des enregistrements (dont l'introduction officielle est prévue à partir de Java 16)

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

Référence: JEP 384: Records \ (Second Preview )

Comment utiliser une bibliothèque externe

Kotlin Standard Library (kotlin.Triple)

Utilisez la bibliothèque standard de Kotlin à partir de Java. La bibliothèque standard de Kotlin comprend Pair, qui gère deux valeurs, et Triple, qui gère trois valeurs.

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

Référence: Triple \ -Kotlin Programming Language

Scala Standard Library (scala.Tuple3)

Utilisez la bibliothèque standard de Scala à partir de Java. Les bibliothèques standard de Scala vont de Tuple1 pour une valeur à Tuple22 pour 22 valeurs.

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

Référence: Scala Standard Library 2 \ .13 \ .3 \ -scala \ .Tuple3

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

Apache Commons Lang a une paire qui gère deux valeurs et une triple qui gère trois valeurs.

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

Référence: [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)

Le Java fonctionnel va de P1 pour une valeur à P8 pour huit valeurs.

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

Référence: P3 \ (core 4 \ .8 \ .1 API )

javatuples (org.javatuples.Triplet)

javatuples va des Unités qui gèrent une valeur à Décennies qui gèrent dix valeurs.

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

Référence: Triplet \ (javatuples 1 \ .2 API )

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

jOOλ va de Tuple0, qui gère 0 valeurs, à Tuple16, qui gère 16 valeurs.

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

Référence: [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)

Reactor va de Tuple2, qui gère deux valeurs, à Tuple8, qui gère huit valeurs.

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

Référence: [Tuple3 \ (réacteur \ -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 va de Tuple0, qui gère 0 valeurs, à Tuple8, qui gère 8 valeurs.

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

Référence: Tuple3 \ (Vavr 0 \ .10 \ .3 API )

Exemple de fichier d'exécution de code

build.gradle

plugins {
  id 'java'
  id 'application'
}

repositories {
  mavenCentral()
}

dependencies {
  //Bibliothèques requises
  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) {
  //Utiliser la fonction de prévisualisation de Java 15
  options.compilerArgs += ['--enable-preview']
}

application {
  //Utiliser la fonction de prévisualisation de Java 15
  applicationDefaultJvmArgs = ['--enable-preview']
}

Exemple de classe d'exécution par lots de code

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

Matériel de référence

Recommended Posts

Comment renvoyer plusieurs valeurs dans une méthode Java (Generics, Record, Triple, Tuple, en utilisant des bibliothèques standard et des bibliothèques externes)
Comment convertir A en A et A en A en utilisant le produit logique et la somme en Java
Essayez d'ajouter du texte à une image avec Scala en utilisant la bibliothèque standard de Java
[Java] Comment chiffrer avec le chiffrement AES avec une bibliothèque standard
Comment essayer la fonction de prévisualisation Java (telle que Java 15 Record) avec IntelliJ
Comment résoudre l'erreur inconnue apparue lors de l'utilisation de slf4j en Java
Comment apprendre JAVA en 7 jours
Comment insérer une bibliothèque externe
[Java] Essayez de mettre en œuvre à l'aide de génériques
Comment utiliser les méthodes de classe [Java]
Comment utiliser les classes en Java?
Comment nommer des variables en Java
Comment concaténer des chaînes avec Java
Comment mettre en œuvre un diaporama en utilisant Slick in Rails (un par un et plusieurs par un)
Comment tester une méthode privée qui prend un tableau ou un argument de longueur variable dans JUnit